GCC Middle and Back End API Reference
expr.h File Reference

Go to the source code of this file.

Data Structures

struct  separate_ops
 
struct  by_pieces_prev
 

Macros

#define NO_DEFER_POP   (inhibit_defer_pop += 1)
 
#define OK_DEFER_POP   (inhibit_defer_pop -= 1)
 

Typedefs

typedef struct separate_opssepops
 
typedef const struct separate_opsconst_sepops
 
typedef rtx(* by_pieces_constfn) (void *, void *, HOST_WIDE_INT, fixed_size_mode)
 

Enumerations

enum  expand_modifier {
  EXPAND_NORMAL = 0 , EXPAND_STACK_PARM , EXPAND_SUM , EXPAND_CONST_ADDRESS ,
  EXPAND_INITIALIZER , EXPAND_WRITE , EXPAND_MEMORY
}
 
enum  block_op_methods {
  BLOCK_OP_NORMAL , BLOCK_OP_NO_LIBCALL , BLOCK_OP_CALL_PARM , BLOCK_OP_TAILCALL ,
  BLOCK_OP_NO_LIBCALL_RET
}
 

Functions

void init_expr_target (void)
 
void init_expr (void)
 
void convert_move (rtx, rtx, int)
 
rtx convert_to_mode (machine_mode, rtx, int)
 
rtx convert_modes (machine_mode mode, machine_mode oldmode, rtx x, int unsignedp)
 
rtx convert_float_to_wider_int (machine_mode mode, machine_mode fmode, rtx x)
 
rtx convert_wider_int_to_float (machine_mode mode, machine_mode imode, rtx x)
 
rtx emit_block_op_via_libcall (enum built_in_function, rtx, rtx, rtx, bool)
 
rtx emit_block_copy_via_libcall (rtx dst, rtx src, rtx size, bool tailcall=false)
 
rtx emit_block_move_via_libcall (rtx dst, rtx src, rtx size, bool tailcall=false)
 
rtx emit_block_comp_via_libcall (rtx dst, rtx src, rtx size, bool tailcall=false)
 
rtx emit_block_move (rtx, rtx, rtx, enum block_op_methods, unsigned ctz_size=0)
 
rtx emit_block_move_hints (rtx, rtx, rtx, enum block_op_methods, unsigned int, HOST_WIDE_INT, unsigned HOST_WIDE_INT, unsigned HOST_WIDE_INT, unsigned HOST_WIDE_INT, bool bail_out_libcall=false, bool *is_move_done=NULL, bool might_overlap=false, unsigned ctz_size=0)
 
rtx emit_block_cmp_hints (rtx, rtx, rtx, tree, rtx, bool, by_pieces_constfn, void *, unsigned ctz_len=0)
 
bool emit_storent_insn (rtx to, rtx from)
 
void move_block_to_reg (int, rtx, int, machine_mode)
 
void move_block_from_reg (int, rtx, int)
 
rtx gen_group_rtx (rtx)
 
void emit_group_load (rtx, rtx, tree, poly_int64)
 
rtx emit_group_load_into_temps (rtx, rtx, tree, poly_int64)
 
void emit_group_move (rtx, rtx)
 
rtx emit_group_move_into_temps (rtx)
 
void emit_group_store (rtx, rtx, tree, poly_int64)
 
rtx maybe_emit_group_store (rtx, tree)
 
void use_reg_mode (rtx *, rtx, machine_mode)
 
void clobber_reg_mode (rtx *, rtx, machine_mode)
 
rtx copy_blkmode_to_reg (machine_mode, tree)
 
void use_reg (rtx *fusage, rtx reg)
 
void clobber_reg (rtx *fusage, rtx reg)
 
void use_regs (rtx *, int, int)
 
void use_group_regs (rtx *, rtx)
 
rtx clear_storage (rtx, rtx, enum block_op_methods)
 
rtx clear_storage_hints (rtx, rtx, enum block_op_methods, unsigned int, HOST_WIDE_INT, unsigned HOST_WIDE_INT, unsigned HOST_WIDE_INT, unsigned HOST_WIDE_INT, unsigned)
 
rtx set_storage_via_libcall (rtx, rtx, rtx, bool=false)
 
bool set_storage_via_setmem (rtx, rtx, rtx, unsigned int, unsigned int, HOST_WIDE_INT, unsigned HOST_WIDE_INT, unsigned HOST_WIDE_INT, unsigned HOST_WIDE_INT)
 
bool can_store_by_pieces (unsigned HOST_WIDE_INT, by_pieces_constfn, void *, unsigned int, bool)
 
rtx store_by_pieces (rtx, unsigned HOST_WIDE_INT, by_pieces_constfn, void *, unsigned int, bool, memop_ret)
 
void clear_by_pieces (rtx, unsigned HOST_WIDE_INT, unsigned int)
 
bool try_store_by_multiple_pieces (rtx to, rtx len, unsigned int ctz_len, unsigned HOST_WIDE_INT min_len, unsigned HOST_WIDE_INT max_len, rtx val, char valc, unsigned int align)
 
rtx_insnemit_move_insn (rtx, rtx)
 
rtx_insngen_move_insn (rtx, rtx)
 
rtx_insnemit_move_insn_1 (rtx, rtx)
 
rtx_insnemit_move_complex_push (machine_mode, rtx, rtx)
 
rtx_insnemit_move_complex_parts (rtx, rtx)
 
rtx read_complex_part (rtx, bool)
 
void write_complex_part (rtx, rtx, bool, bool)
 
rtx emit_move_resolve_push (machine_mode, rtx)
 
rtx push_block (rtx, poly_int64, int)
 
bool emit_push_insn (rtx, machine_mode, tree, rtx, unsigned int, int, rtx, poly_int64, rtx, rtx, int, rtx, bool)
 
void get_bit_range (poly_uint64 *, poly_uint64 *, tree, poly_int64 *, tree *)
 
void expand_assignment (tree, tree, bool)
 
rtx store_expr (tree, rtx, int, bool, bool)
 
rtx force_operand (rtx, rtx)
 
rtx expand_expr_real (tree, rtx, machine_mode, enum expand_modifier, rtx *, bool)
 
rtx expand_expr_real_1 (tree, rtx, machine_mode, enum expand_modifier, rtx *, bool)
 
rtx expand_expr_real_2 (const_sepops, rtx, machine_mode, enum expand_modifier)
 
rtx expand_expr_real_gassign (gassign *, rtx, machine_mode, enum expand_modifier modifier, rtx *=nullptr, bool=false)
 
rtx expand_expr (tree exp, rtx target, machine_mode mode, enum expand_modifier modifier)
 
rtx expand_normal (tree exp)
 
tree string_constant (tree, tree *, tree *, tree *)
 
tree byte_representation (tree, tree *, tree *, tree *)
 
enum tree_code maybe_optimize_mod_cmp (enum tree_code, tree *, tree *)
 
void maybe_optimize_sub_cmp_0 (enum tree_code, tree *, tree *)
 
bool try_casesi (tree, tree, tree, tree, rtx, rtx, rtx, profile_probability)
 
bool try_tablejump (tree, tree, tree, tree, rtx, rtx, profile_probability)
 
bool safe_from_p (const_rtx, tree, int)
 
rtx get_personality_function (tree)
 
bool can_move_by_pieces (unsigned HOST_WIDE_INT, unsigned int)
 
unsigned HOST_WIDE_INT highest_pow2_factor (const_tree)
 
bool categorize_ctor_elements (const_tree, HOST_WIDE_INT *, HOST_WIDE_INT *, HOST_WIDE_INT *, bool *)
 
bool immediate_const_ctor_p (const_tree, unsigned int words=1)
 
void store_constructor (tree, rtx, int, poly_int64, bool)
 
HOST_WIDE_INT int_expr_size (const_tree exp)
 
void expand_operands (tree, tree, rtx, rtx *, rtx *, enum expand_modifier)
 
rtx expr_size (tree)
 
bool mem_ref_refers_to_non_mem_p (tree)
 
bool non_mem_decl_p (tree)
 

Macro Definition Documentation

◆ NO_DEFER_POP

#define NO_DEFER_POP   (inhibit_defer_pop += 1)
Prevent the compiler from deferring stack pops.  See
inhibit_defer_pop for more information.   

Referenced by emit_block_move_hints(), emit_library_call_value_1(), expand_abs(), expand_builtin_apply(), expand_call(), expand_doubleword_shift(), expand_expr_real_2(), store_expr(), and store_one_arg().

◆ OK_DEFER_POP

#define OK_DEFER_POP   (inhibit_defer_pop -= 1)
Allow the compiler to defer stack pops.  See inhibit_defer_pop for
more information.   

Referenced by emit_block_move_hints(), emit_library_call_value_1(), expand_abs(), expand_builtin_apply(), expand_call(), expand_doubleword_shift(), expand_expr_real_2(), and store_expr().

Typedef Documentation

◆ by_pieces_constfn

typedef rtx(* by_pieces_constfn) (void *, void *, HOST_WIDE_INT, fixed_size_mode)

◆ const_sepops

typedef const struct separate_ops* const_sepops

◆ sepops

typedef struct separate_ops * sepops
This structure is used to pass around information about exploded
unary, binary and trinary expressions between expand_expr_real_1 and
friends.   

Enumeration Type Documentation

◆ block_op_methods

Emit code to move a block Y to a block X.   
Enumerator
BLOCK_OP_NORMAL 
BLOCK_OP_NO_LIBCALL 
BLOCK_OP_CALL_PARM 
BLOCK_OP_TAILCALL 
BLOCK_OP_NO_LIBCALL_RET 

◆ expand_modifier

Definitions for code generation pass of GNU compiler.
   Copyright (C) 1987-2024 Free Software Foundation, Inc.

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/>.   
This is the 4th arg to `expand_expr'.
EXPAND_STACK_PARM means we are possibly expanding a call param onto
the stack.
EXPAND_SUM means it is ok to return a PLUS rtx or MULT rtx.
EXPAND_INITIALIZER is similar but also record any labels on forced_labels.
EXPAND_CONST_ADDRESS means it is ok to return a MEM whose address
 is a constant that is not a legitimate address.
EXPAND_WRITE means we are only going to write to the resulting rtx.
EXPAND_MEMORY means we are interested in a memory result, even if
 the memory is constant and we could have propagated a constant value,
 or the memory is unaligned on a STRICT_ALIGNMENT target.   
Enumerator
EXPAND_NORMAL 
EXPAND_STACK_PARM 
EXPAND_SUM 
EXPAND_CONST_ADDRESS 
EXPAND_INITIALIZER 
EXPAND_WRITE 
EXPAND_MEMORY 

Function Documentation

◆ byte_representation()

tree byte_representation ( tree arg,
tree * ptr_offset,
tree * mem_size,
tree * decl )
extern
Similar to string_constant, return a STRING_CST corresponding
to the value representation of the first argument if it's
a constant.   

References constant_byte_string().

Referenced by getbyterep(), and gimple_fold_builtin_memchr().

◆ can_move_by_pieces()

bool can_move_by_pieces ( unsigned HOST_WIDE_INT len,
unsigned int align )
extern
Determine whether the LEN bytes can be moved by using several move
instructions.  Return nonzero if a call to move_by_pieces should
succeed.   

References can_do_by_pieces(), and MOVE_BY_PIECES.

Referenced by emit_block_move_hints(), emit_block_move_via_loop(), emit_block_move_via_sized_loop(), emit_push_insn(), expand_constructor(), gimple_stringops_transform(), and gimplify_init_constructor().

◆ can_store_by_pieces()

bool can_store_by_pieces ( unsigned HOST_WIDE_INT len,
by_pieces_constfn constfun,
void * constfundata,
unsigned int align,
bool memsetp )
extern
Return true if it is desirable to store LEN bytes generated by
CONSTFUN with several move instructions by store_by_pieces
function.  CONSTFUNDATA is a pointer which will be passed as argument
in every CONSTFUN call.
ALIGN is maximum alignment we can assume.
MEMSETP is true if this is a real memset/bzero, not a copy
of a const string.   
Determine whether the LEN bytes generated by CONSTFUN can be
stored to memory using several move instructions.  CONSTFUNDATA is
a pointer which will be passed as argument in every CONSTFUN call.
ALIGN is maximum alignment we can assume.  MEMSETP is true if this is
a memset operation and false if it's a copy of a constant string.
Return true if a call to store_by_pieces should succeed.   

References alignment_for_piecewise_move(), gcc_assert, GET_MODE_ALIGNMENT, GET_MODE_SIZE(), HAVE_POST_DECREMENT, HAVE_PRE_DECREMENT, offset, optab_handler(), optimize_insn_for_speed_p(), SET_BY_PIECES, STORE_BY_PIECES, STORE_MAX_PIECES, targetm, VECTOR_MODE_P, and widest_fixed_size_mode_for_size().

Referenced by asan_emit_stack_protection(), can_store_by_multiple_pieces(), expand_builtin_memory_copy_args(), expand_builtin_memset_args(), expand_builtin_strncpy(), gimple_stringops_transform(), simplify_builtin_call(), store_expr(), and try_store_by_multiple_pieces().

◆ categorize_ctor_elements()

bool categorize_ctor_elements ( const_tree ctor,
HOST_WIDE_INT * p_nz_elts,
HOST_WIDE_INT * p_unique_nz_elts,
HOST_WIDE_INT * p_init_elts,
bool * p_complete )
extern
Examine CTOR to discover:
* how many scalar fields are set to nonzero values,
  and place it in *P_NZ_ELTS;
* the same, but counting RANGE_EXPRs as multiplier of 1 instead of
  high - low + 1 (this can be useful for callers to determine ctors
  that could be cheaply initialized with - perhaps nested - loops
  compared to copied from huge read-only data),
  and place it in *P_UNIQUE_NZ_ELTS;
* how many scalar fields in total are in CTOR,
  and place it in *P_ELT_COUNT.
* whether the constructor is complete -- in the sense that every
  meaningful byte is explicitly given a value --
  and place it in *P_COMPLETE.

Return whether or not CTOR is a valid static constant initializer, the same
as "initializer_constant_valid_p (CTOR, TREE_TYPE (CTOR)) != 0".   

References categorize_ctor_elements_1().

Referenced by all_zeros_p(), gimplify_init_constructor(), and mostly_zeros_p().

◆ clear_by_pieces()

void clear_by_pieces ( rtx to,
unsigned HOST_WIDE_INT,
unsigned int align )
extern
Generate several move instructions to clear LEN bytes of block TO.  (A MEM
rtx with BLKmode).  ALIGN is maximum alignment we can assume.   

References builtin_memset_read_str(), and CLEAR_BY_PIECES.

Referenced by clear_storage_hints().

◆ clear_storage()

rtx clear_storage ( rtx object,
rtx size,
enum block_op_methods )
extern
Write zeros through the storage of OBJECT.
If OBJECT has BLKmode, SIZE is its length in bytes.   

References clear_storage_hints(), GET_CODE, GET_MODE, GET_MODE_MASK, and UINTVAL.

Referenced by asan_clear_shadow(), expand_constructor(), store_constructor(), and store_expr().

◆ clear_storage_hints()

rtx clear_storage_hints ( rtx object,
rtx size,
enum block_op_methods method,
unsigned int expected_align,
HOST_WIDE_INT expected_size,
unsigned HOST_WIDE_INT min_size,
unsigned HOST_WIDE_INT max_size,
unsigned HOST_WIDE_INT probable_max_size,
unsigned ctz_size )
extern

◆ clobber_reg()

void clobber_reg ( rtx * fusage,
rtx reg )
inline
Mark REG as clobbered by the call with FUSAGE as CALL_INSN_FUNCTION_USAGE.   

References clobber_reg_mode().

◆ clobber_reg_mode()

void clobber_reg_mode ( rtx * call_fusage,
rtx reg,
machine_mode mode )
extern
Add a CLOBBER expression for REG to the (possibly empty) list pointed
to by CALL_FUSAGE.  REG must denote a hard register.   

References gcc_assert, gen_rtx_EXPR_LIST(), expand_operand::mode, REG_P, and REGNO.

Referenced by clobber_reg().

◆ convert_float_to_wider_int()

rtx convert_float_to_wider_int ( machine_mode mode,
machine_mode fmode,
rtx x )
extern
Variant of convert_modes for ABI parameter passing/return.   
Variant of convert_modes for ABI parameter passing/return.
Return an rtx for a value that would result from converting X from
a floating point mode FMODE to wider integer mode MODE.   

References convert_modes(), force_reg(), gcc_assert, gen_lowpart, int_mode_for_mode(), opt_mode< T >::require(), SCALAR_FLOAT_MODE_P, and SCALAR_INT_MODE_P.

Referenced by expand_value_return(), and precompute_register_parameters().

◆ convert_modes()

rtx convert_modes ( machine_mode mode,
machine_mode oldmode,
rtx x,
int unsignedp )
extern
Convert an rtx to MODE from OLDMODE and return the result.   
Return an rtx for a value that would result
from converting X from mode OLDMODE to mode MODE.
Both modes may be floating, or both integer.
UNSIGNEDP is nonzero if X is an unsigned value.

This can be done by referring to a part of X in place
or by copying to a new temporary with conversion.

You can give VOIDmode for OLDMODE, if you are sure X has a nonvoid mode.   

References CONST_POLY_INT_P, CONST_SCALAR_INT_P, convert_move(), direct_load, force_subreg(), wide_int_storage::from(), gcc_assert, gen_lowpart, gen_reg_rtx(), GET_CODE, GET_MODE, GET_MODE_BITSIZE(), GET_MODE_PRECISION(), HARD_REGISTER_P, immed_wide_int_const(), is_a(), is_int_mode(), known_eq, MEM_P, MEM_VOLATILE_P, REG_P, REGNO, SIGNED, SUBREG_CHECK_PROMOTED_SIGN, subreg_promoted_mode(), SUBREG_PROMOTED_SET, SUBREG_PROMOTED_VAR_P, SUBREG_REG, targetm, TRULY_NOOP_TRUNCATION_MODES_P, UNSIGNED, and VECTOR_MODE_P.

Referenced by avoid_expensive_constant(), can_widen_mult_without_libcall(), convert_float_to_wider_int(), convert_memory_address_addr_space_1(), convert_to_mode(), emit_block_cmp_via_loop(), emit_block_move_via_loop(), emit_block_move_via_oriented_loop(), emit_library_call_value_1(), emit_store_flag_1(), emit_store_flag_int(), expand_arith_overflow_result_store(), expand_asan_emit_allocas_unpoison(), expand_binop_directly(), expand_builtin_extend_pointer(), expand_builtin_issignaling(), expand_cond_expr_using_cmove(), expand_divmod(), expand_doubleword_mod(), expand_expr_addr_expr_1(), expand_expr_force_mode(), expand_expr_real_1(), expand_expr_real_2(), expand_gimple_stmt_1(), expand_ifn_atomic_compare_exchange(), expand_ifn_atomic_compare_exchange_into_call(), expand_mul_overflow(), expand_speculation_safe_value(), expand_twoval_binop(), expand_twoval_unop(), expand_value_return(), expand_widening_mult(), expmed_mult_highpart_optab(), extract_high_half(), extract_low_bits(), inline_string_cmp(), insert_value_copy_on_edge(), maybe_legitimize_operand(), optimize_bitfield_assignment_op(), precompute_arguments(), precompute_register_parameters(), prepare_operand(), push_block(), store_expr(), store_field(), store_one_arg(), try_tablejump(), and widen_operand().

◆ convert_move()

void convert_move ( rtx to,
rtx from,
int unsignedp )
extern
Emit some rtl insns to move data between rtx's, converting machine modes.
Both modes must be floating or both fixed.   
Copy data from FROM to TO, where the machine modes are not the same.
Both modes may be integer, or both may be floating, or both may be
fixed-point.
UNSIGNEDP should be nonzero if FROM is an unsigned type.
This causes zero-extension instead of sign-extension.   

References CONSTANT_P, convert_mode_scalar(), convert_move(), convert_optab_handler(), emit_move_insn(), emit_unop_insn(), force_subreg(), gcc_assert, gen_lowpart, GET_CODE, GET_MODE, GET_MODE_BITSIZE(), GET_MODE_PRECISION(), GET_MODE_UNIT_PRECISION, is_a(), known_eq, simplify_gen_subreg(), SUBREG_CHECK_PROMOTED_SIGN, subreg_promoted_mode(), SUBREG_PROMOTED_SET, SUBREG_PROMOTED_VAR_P, SUBREG_REG, VECTOR_MODE_P, and XEXP.

Referenced by assign_call_lhs(), convert_mode_scalar(), convert_modes(), convert_move(), do_tablejump(), doloop_modify(), emit_block_cmp_via_loop(), emit_conditional_add(), emit_conditional_move_1(), emit_conditional_neg_or_complement(), emit_cstore(), emit_store_flag_1(), emit_store_flag_int(), expand_assignment(), expand_binop(), expand_builtin_memcmp(), expand_builtin_strcmp(), expand_builtin_strlen(), expand_builtin_strncmp(), expand_doubleword_clz_ctz_ffs(), expand_expr_real_1(), expand_expr_real_2(), expand_ffs(), expand_fix(), expand_float(), expand_function_end(), expand_function_start(), expand_gimple_stmt_1(), expand_sfix_optab(), expand_single_bit_test(), expand_twoval_binop(), expand_twoval_unop(), expand_ubsan_result_store(), expand_unop(), force_operand(), std_expand_builtin_va_start(), store_bit_field_using_insv(), store_constructor(), and store_expr().

◆ convert_to_mode()

rtx convert_to_mode ( machine_mode mode,
rtx x,
int unsignedp )
extern
Convert an rtx to specified machine mode and return the result.   
Return an rtx for a value that would result
from converting X to mode MODE.
Both X and MODE may be floating, or both integer.
UNSIGNEDP is nonzero if X is an unsigned value.
This can be done by referring to a part of X in place
or by copying to a new temporary with conversion.   

References convert_modes().

Referenced by anti_adjust_stack_and_probe(), anti_adjust_stack_and_probe_stack_clash(), assign_call_lhs(), assign_parm_setup_block(), assign_parm_setup_reg(), assign_parm_setup_stack(), builtin_memset_gen_str(), convert_extracted_bit_field(), convert_mode_scalar(), copy_blkmode_from_reg(), do_tablejump(), emit_block_op_via_libcall(), emit_partition_copy(), expand_assignment(), expand_binop(), expand_builtin_bswap(), expand_builtin_extract_return_addr(), expand_builtin_int_roundingfn_2(), expand_builtin_interclass_mathfn(), expand_builtin_memcmp(), expand_builtin_memset_args(), expand_builtin_powi(), expand_builtin_stack_address(), expand_builtin_strcmp(), expand_builtin_strlen(), expand_builtin_strncmp(), expand_builtin_unop(), expand_expr_real_1(), expand_expr_real_2(), expand_fix(), expand_float(), expand_parity(), expand_POPCOUNT(), expand_sfix_optab(), expand_widening_mult(), expmed_mult_highpart(), extract_fixed_bit_field_1(), get_dynamic_stack_size(), maybe_legitimize_operand(), prepare_cmp_insn(), prepare_float_lib_cmp(), prepare_libcall_arg(), probe_stack_range(), set_storage_via_libcall(), sjlj_emit_dispatch_table(), store_expr(), store_fixed_bit_field_1(), try_casesi(), and try_store_by_multiple_pieces().

◆ convert_wider_int_to_float()

rtx convert_wider_int_to_float ( machine_mode mode,
machine_mode imode,
rtx x )
extern
Variant of convert_modes for ABI parameter passing/return.   
Variant of convert_modes for ABI parameter passing/return.
Return an rtx for a value that would result from converting X from
an integer mode IMODE to a narrower floating point mode MODE.   

References force_reg(), gcc_assert, gen_lowpart, gen_lowpart_SUBREG(), int_mode_for_mode(), opt_mode< T >::require(), SCALAR_FLOAT_MODE_P, and SCALAR_INT_MODE_P.

Referenced by assign_parm_setup_stack(), expand_call(), and expand_expr_real_1().

◆ copy_blkmode_to_reg()

rtx copy_blkmode_to_reg ( machine_mode mode_in,
tree src )
extern

◆ emit_block_cmp_hints()

rtx emit_block_cmp_hints ( rtx x,
rtx y,
rtx len,
tree len_type,
rtx target,
bool equality_only,
by_pieces_constfn y_cfn,
void * y_cfndata,
unsigned ctz_len )
extern
Emit code to compare a block Y to a block X.  This may be done with
string-compare instructions, with multiple scalar instructions,
or with a library call.

Both X and Y must be MEM rtx's.  LEN is an rtx that says how long
they are.  LEN_TYPE is the type of the expression that was used to
calculate it, and CTZ_LEN is the known trailing-zeros count of LEN,
so LEN must be a multiple of 1<<CTZ_LEN even if it's not constant.

If EQUALITY_ONLY is true, it means we don't have to return the tri-state
value of a normal memcmp call, instead we can just compare for equality.
If FORCE_LIBCALL is true, we should emit a call to memcmp rather than
returning NULL_RTX.

Optionally, the caller can pass a constfn and associated data in Y_CFN
and Y_CFN_DATA. describing that the second operand being compared is a
known constant and how to obtain its data.
Return the result of the comparison, or NULL_RTX if we failed to
perform the operation.   

References adjust_address, can_do_by_pieces(), COMPARE_BY_PIECES, compare_by_pieces(), const0_rtx, CONST_INT_P, emit_block_cmp_via_cmpmem(), emit_block_cmp_via_loop(), gcc_assert, ILSOP_MEMCMP, INTVAL, MEM_ALIGN, MEM_P, MIN, expand_operand::target, and y.

Referenced by expand_builtin_memcmp().

◆ emit_block_comp_via_libcall()

rtx emit_block_comp_via_libcall ( rtx dst,
rtx src,
rtx size,
bool tailcall = false )
inline

References emit_block_op_via_libcall().

Referenced by prepare_cmp_insn().

◆ emit_block_copy_via_libcall()

rtx emit_block_copy_via_libcall ( rtx dst,
rtx src,
rtx size,
bool tailcall = false )
inline

◆ emit_block_move()

rtx emit_block_move ( rtx ,
rtx ,
rtx ,
enum block_op_methods,
unsigned ctz_size = 0 )
extern

◆ emit_block_move_hints()

rtx emit_block_move_hints ( rtx x,
rtx y,
rtx size,
enum block_op_methods method,
unsigned int expected_align,
HOST_WIDE_INT expected_size,
unsigned HOST_WIDE_INT min_size,
unsigned HOST_WIDE_INT max_size,
unsigned HOST_WIDE_INT probable_max_size,
bool bail_out_libcall,
bool * is_move_done,
bool might_overlap,
unsigned ctz_size )
extern
Emit code to move a block Y to a block X.  This may be done with
string-move instructions, with multiple scalar move instructions,
or with a library call.

Both X and Y must be MEM rtx's (perhaps inside VOLATILE) with mode BLKmode.
SIZE is an rtx that says how long they are.
ALIGN is the maximum alignment we can assume they have.
METHOD describes what kind of copy this is, and what mechanisms may be used.
MIN_SIZE is the minimal size of block to move
MAX_SIZE is the maximal size of block to move, if it cannot be represented
in unsigned HOST_WIDE_INT, than it is mask of all ones.
CTZ_SIZE is the trailing-zeros count of SIZE; even a nonconstant SIZE is
known to be a multiple of 1<<CTZ_SIZE.

Return the address of the new block, if memcpy is called and returns it,
0 otherwise.   

References ADDR_SPACE_GENERIC_P, adjust_address, block_move_libcall_safe_for_call_parm(), BLOCK_OP_CALL_PARM, BLOCK_OP_NO_LIBCALL, BLOCK_OP_NO_LIBCALL_RET, BLOCK_OP_NORMAL, BLOCK_OP_TAILCALL, can_move_by_pieces(), CONST_INT_P, emit_block_copy_via_libcall(), emit_block_move_via_oriented_loop(), emit_block_move_via_pattern(), emit_block_move_via_sized_loop(), gcc_assert, gcc_unreachable, ILSOP_MEMCPY, ILSOP_MEMMOVE, INTVAL, MEM_ADDR_SPACE, MEM_ALIGN, MEM_P, MEM_VOLATILE_P, MIN, move_by_pieces(), NO_DEFER_POP, OK_DEFER_POP, pc_rtx, poly_int_rtx_p(), RETURN_BEGIN, rtx_equal_p(), set_mem_size(), shallow_copy_rtx(), and y.

Referenced by emit_block_move(), emit_block_move_via_loop(), and expand_builtin_memory_copy_args().

◆ emit_block_move_via_libcall()

rtx emit_block_move_via_libcall ( rtx dst,
rtx src,
rtx size,
bool tailcall = false )
inline

◆ emit_block_op_via_libcall()

rtx emit_block_op_via_libcall ( enum built_in_function fncode,
rtx dst,
rtx src,
rtx size,
bool tailcall )
extern
Expand a call to memcpy or memmove or memcmp, and return the result.   
Expand a call to memcpy or memmove or memcmp, and return the result.
TAILCALL is true if this is a tail call.   

References build_call_expr(), builtin_decl_implicit(), CALL_EXPR_TAILCALL, convert_memory_address, convert_to_mode(), copy_addr_to_reg(), copy_to_mode_reg(), expand_call(), make_tree(), mark_addressable(), MEM_EXPR, NULL_RTX, ptr_mode, ptr_type_node, sizetype, TYPE_MODE, and XEXP.

Referenced by emit_block_comp_via_libcall(), emit_block_copy_via_libcall(), and emit_block_move_via_libcall().

◆ emit_group_load()

void emit_group_load ( rtx dst,
rtx src,
tree type,
poly_int64 ssize )
extern
Load a BLKmode value into non-consecutive registers represented by a
PARALLEL.   
Emit code to move a block SRC of type TYPE to a block DST,
where DST is non-consecutive registers represented by a PARALLEL.
SSIZE represents the total size of block ORIG_SRC in bytes, or -1
if not known.   

References emit_group_load_1(), emit_move_insn(), i, NULL, XEXP, XVECEXP, and XVECLEN.

Referenced by emit_group_store(), emit_library_call_value_1(), emit_push_insn(), expand_assignment(), expand_function_end(), expand_value_return(), and store_expr().

◆ emit_group_load_into_temps()

rtx emit_group_load_into_temps ( rtx parallel,
rtx src,
tree type,
poly_int64 ssize )
extern
Similarly, but load into new temporaries.   
Similar, but load SRC into new pseudos in a format that looks like
PARALLEL.  This can later be fed to emit_group_move to get things
in the right place.   

References alloc_EXPR_LIST(), emit_group_load_1(), force_reg(), GET_MODE, i, REG_NOTE_KIND, rtvec_alloc(), RTVEC_ELT, XEXP, XVECEXP, and XVECLEN.

Referenced by precompute_register_parameters(), and store_one_arg().

◆ emit_group_move()

void emit_group_move ( rtx dst,
rtx src )
extern
Move a non-consecutive group of registers represented by a PARALLEL into
a non-consecutive group of registers represented by a PARALLEL.   
Emit code to move a block SRC to block DST, where SRC and DST are
non-consecutive groups of registers, each represented by a PARALLEL.   

References emit_move_insn(), gcc_assert, GET_CODE, i, XEXP, XVECEXP, and XVECLEN.

Referenced by expand_assignment(), expand_call(), expand_function_end(), load_register_parameters(), and store_expr().

◆ emit_group_move_into_temps()

rtx emit_group_move_into_temps ( rtx src)
extern
Move a group of registers represented by a PARALLEL into pseudos.   

References alloc_EXPR_LIST(), copy_to_reg(), GET_MODE, i, REG_NOTE_KIND, rtvec_alloc(), RTVEC_ELT, XEXP, XVECEXP, and XVECLEN.

Referenced by assign_parm_setup_block(), and expand_call().

◆ emit_group_store()

◆ emit_move_complex_parts()

rtx_insn * emit_move_complex_parts ( rtx x,
rtx y )
extern
A subroutine of emit_move_complex.  Perform the move from Y to X
via two moves of the parts.  Returns the last instruction emitted.   

References emit_clobber(), get_last_insn(), read_complex_part(), reg_overlap_mentioned_p(), REG_P, reload_completed, reload_in_progress, write_complex_part(), and y.

Referenced by emit_move_complex().

◆ emit_move_complex_push()

rtx_insn * emit_move_complex_push ( machine_mode mode,
rtx x,
rtx y )
extern
A subroutine of emit_move_complex.  Generate a move from Y into X.
X is known to satisfy push_operand, and MODE is known to be complex.
Returns the last instruction emitted.   

References emit_move_insn(), emit_move_resolve_push(), gcc_unreachable, gen_rtx_MEM(), GET_CODE, GET_MODE_INNER, GET_MODE_SIZE(), expand_operand::mode, read_complex_part(), XEXP, and y.

Referenced by emit_move_complex().

◆ emit_move_insn()

rtx_insn * emit_move_insn ( rtx x,
rtx y )
extern
Emit insns to set X from Y.   
Generate code to copy Y into X.
Both Y and X must have the same mode, except that
Y can be a constant with VOIDmode.
This mode cannot be BLKmode; use emit_block_move for that.

Return the last instruction emitted.   

References adjust_address, compress_float_constant(), CONSTANT_P, copy_rtx(), emit_move_insn_1(), force_const_mem(), gcc_assert, GET_MODE, GET_MODE_ALIGNMENT, GET_MODE_SIZE(), known_eq, MEM_ADDR_SPACE, MEM_ALIGN, MEM_P, memory_address_addr_space_p(), expand_operand::mode, NULL_RTX, optab_handler(), push_operand(), REG_P, rtx_equal_p(), SCALAR_FLOAT_MODE_P, SET_DEST, SET_SRC, set_unique_reg_note(), simplify_subreg(), single_set(), SUBREG_P, SUBREG_REG, targetm, use_anchored_address(), validize_mem(), XEXP, and y.

Referenced by adjust_stack_1(), allocate_dynamic_stack_space(), asan_clear_shadow(), asan_emit_stack_protection(), assign_call_lhs(), assign_parm_setup_block(), assign_parm_setup_reg(), assign_parm_setup_stack(), assign_parms_unsplit_complex(), attempt_change(), avoid_likely_spilled_reg(), builtin_memset_gen_str(), builtin_memset_read_str(), clear_storage_hints(), combine_reaching_defs(), combine_var_copies_in_loop_exit(), compare_by_pieces(), compress_float_constant(), convert_mode_scalar(), convert_move(), copy_blkmode_from_reg(), copy_blkmode_to_reg(), copy_to_mode_reg(), copy_to_reg(), copy_to_suggested_reg(), curr_insn_transform(), default_speculation_safe_value(), default_zero_call_used_regs(), do_jump_by_parts_zero_rtx(), emit_block_cmp_via_loop(), emit_block_move_via_loop(), emit_conditional_move(), emit_conditional_move_1(), emit_group_load(), emit_group_load_1(), emit_group_move(), emit_group_store(), emit_initial_value_sets(), emit_libcall_block_1(), emit_library_call_value_1(), emit_move_complex_push(), emit_move_list(), emit_move_multi_word(), emit_move_resolve_push(), emit_partition_copy(), emit_push_insn(), emit_stack_probe(), emit_store_flag_force(), emit_store_flag_int(), expand_abs(), expand_absneg_bit(), expand_and(), expand_asm_stmt(), expand_assignment(), expand_atomic_compare_and_swap(), expand_atomic_fetch_op(), expand_atomic_load(), expand_atomic_store(), expand_binop(), expand_BITINTTOFLOAT(), expand_builtin_apply(), expand_builtin_apply_args_1(), expand_builtin_atomic_clear(), expand_builtin_atomic_compare_exchange(), expand_builtin_eh_copy_values(), expand_builtin_eh_return(), expand_BUILTIN_EXPECT(), expand_builtin_goacc_parlevel_id_size(), expand_builtin_init_descriptor(), expand_builtin_issignaling(), expand_builtin_longjmp(), expand_builtin_nonlocal_goto(), expand_builtin_return(), expand_builtin_setjmp_receiver(), expand_builtin_setjmp_setup(), expand_builtin_sincos(), expand_builtin_stpcpy_1(), expand_builtin_strlen(), expand_builtin_strub_enter(), expand_builtin_strub_leave(), expand_builtin_strub_update(), expand_call(), expand_compare_and_swap_loop(), expand_copysign_absneg(), expand_copysign_bit(), expand_dec(), expand_DIVMOD(), expand_divmod(), expand_doubleword_bswap(), expand_doubleword_mult(), expand_dw2_landing_pad_for_region(), expand_eh_return(), expand_expr_real_1(), expand_expr_real_2(), expand_fix(), expand_fixed_convert(), expand_float(), expand_function_end(), expand_function_start(), expand_gimple_stmt_1(), expand_GOACC_DIM_POS(), expand_GOACC_DIM_SIZE(), expand_HWASAN_CHOOSE_TAG(), expand_HWASAN_SET_TAG(), expand_ifn_atomic_bit_test_and(), expand_ifn_atomic_compare_exchange_into_call(), expand_ifn_atomic_op_fetch_cmp_0(), expand_inc(), expand_movstr(), expand_mul_overflow(), expand_mult_const(), expand_one_ssa_partition(), expand_POPCOUNT(), expand_SET_EDOM(), expand_smod_pow2(), expand_subword_shift(), expand_superword_shift(), expand_ubsan_result_store(), expand_unop(), expand_value_return(), expand_vec_set_optab_fn(), expand_vector_ubsan_overflow(), extract_bit_field_1(), extract_integral_bit_field(), find_shift_sequence(), fix_crossing_unconditional_branches(), asan_redzone_buffer::flush_redzone_payload(), force_expand_binop(), force_not_mem(), force_operand(), force_reg(), get_arg_pointer_save_area(), get_dynamic_stack_base(), inherit_in_ebb(), init_one_dwarf_reg_size(), init_return_column_size(), init_set_costs(), initialize_uninitialized_regs(), inline_string_cmp(), insert_base_initialization(), insert_value_copy_on_edge(), insert_var_expansion_initialization(), instantiate_virtual_regs_in_insn(), load_register_parameters(), lra_emit_add(), lra_emit_move(), make_safe_from(), match_asm_constraints_1(), maybe_emit_unop_insn(), move_block_from_reg(), move_block_to_reg(), noce_emit_cmove(), noce_emit_move_insn(), optimize_bitfield_assignment_op(), prepare_call_address(), prepare_copy_insn(), probe_stack_range(), resolve_shift_zext(), resolve_simple_move(), sjlj_emit_dispatch_table(), sjlj_emit_function_enter(), sjlj_mark_call_sites(), split_iv(), stack_protect_prologue(), store_bit_field(), store_bit_field_1(), store_bit_field_using_insv(), store_constructor(), store_expr(), store_fixed_bit_field_1(), store_integral_bit_field(), store_one_arg(), store_unaligned_arguments_into_pseudos(), try_store_by_multiple_pieces(), unroll_loop_runtime_iterations(), widen_bswap(), widen_operand(), and write_complex_part().

◆ emit_move_insn_1()

rtx_insn * emit_move_insn_1 ( rtx x,
rtx y )
extern
Emit insns to set X from Y, with no frills.   
Low level part of emit_move_insn.
Called just like emit_move_insn, but assumes X and Y
are basically valid.   

References ALL_FIXED_POINT_MODE_P, COMPLEX_MODE_P, CONSTANT_P, emit_insn(), emit_move_ccmode(), emit_move_complex(), emit_move_multi_word(), emit_move_via_integer(), gcc_assert, GET_MODE, GET_MODE_BITSIZE(), GET_MODE_CLASS, HOST_BITS_PER_WIDE_INT, known_le, lra_in_progress, expand_operand::mode, optab_handler(), PATTERN(), recog(), and y.

Referenced by emit_move_insn(), and gen_move_insn().

◆ emit_move_resolve_push()

rtx emit_move_resolve_push ( machine_mode mode,
rtx x )
extern
A subroutine of emit_move_insn_1.  X is a push_operand in MODE.
Return an equivalent MEM that does not use an auto-increment.   

References emit_move_insn(), expand_simple_binop(), gcc_assert, gcc_unreachable, gen_int_mode(), GET_CODE, GET_MODE_SIZE(), known_eq, expand_operand::mode, OPTAB_LIB_WIDEN, plus_constant(), replace_equiv_address(), rtx_to_poly_int64(), stack_pointer_rtx, and XEXP.

Referenced by emit_move_complex_push(), and emit_move_multi_word().

◆ emit_push_insn()

bool emit_push_insn ( rtx x,
machine_mode mode,
tree type,
rtx size,
unsigned int align,
int partial,
rtx reg,
poly_int64 extra,
rtx args_addr,
rtx args_so_far,
int reg_parm_stack_space,
rtx alignment_pad,
bool sibcall_p )
extern
Generate code to push something onto the stack, given its mode and type.   
Generate code to push X onto the stack, assuming it has mode MODE and
type TYPE.
MODE is redundant except when X is a CONST_INT (since they don't
carry mode info).
SIZE is an rtx for the size of data to be copied (in bytes),
needed only if X is BLKmode.
Return true if successful.  May return false if asked to push a
partial argument during a sibcall optimization (as specified by
SIBCALL_P) and the incoming and outgoing pointers cannot be shown
to not overlap.

ALIGN (in bits) is maximum alignment we can assume.

If PARTIAL and REG are both nonzero, then copy that many of the first
bytes of X into registers starting with REG, and push the rest of X.
The amount of space pushed is decreased by PARTIAL bytes.
REG must be a hard register in this case.
If REG is zero but PARTIAL is not, take any all others actions for an
argument partially in registers, but do not actually load any
registers.

EXTRA is the amount in bytes of extra space to leave next to this arg.
This is ignored if an argument block has already been allocated.

On a machine that lacks real push insns, ARGS_ADDR is the address of
the bottom of the argument block for this call.  We use indexing off there
to store the arg.  On machines with push insns, ARGS_ADDR is 0 when a
argument block has not been preallocated.

ARGS_SO_FAR is the size of args previously pushed for this call.

REG_PARM_STACK_SPACE is nonzero if functions require stack space
for arguments passed in registers.  If nonzero, it will be the number
of bytes required.   

References ACCUMULATE_OUTGOING_ARGS, adjust_address, anti_adjust_stack(), assign_temp(), BLOCK_OP_CALL_PARM, can_move_by_pieces(), CONST_INT_P, CONSTANT_P, copy_to_reg(), DECL_INITIAL, emit_block_move(), emit_group_load(), emit_move_insn(), emit_push_insn(), expand_binop(), force_const_mem(), gcc_assert, GEN_INT, gen_int_mode(), gen_reg_rtx(), gen_rtx_MEM(), gen_rtx_REG(), GET_CODE, GET_MODE, GET_MODE_ALIGNMENT, GET_MODE_CLASS, GET_MODE_SIZE(), i, immediate_const_ctor_p(), int_expr_size(), INTVAL, known_eq, MEM_ALIGN, MEM_P, memory_address, memory_load_overlap(), expand_operand::mode, move_block_to_reg(), move_by_pieces(), NULL, NULL_RTX, NULL_TREE, offset, operand_subword_force(), OPTAB_LIB_WIDEN, PAD_DOWNWARD, PAD_NONE, PAD_UPWARD, plus_constant(), poly_int_rtx_p(), push_block(), reg_mentioned_p(), REG_P, REGNO, RETURN_BEGIN, set_mem_align(), simplify_gen_binary(), STACK_GROWS_DOWNWARD, STACK_PUSH_CODE, store_constructor(), SYMBOL_REF_DECL, SYMBOL_REF_P, expand_operand::target, targetm, poly_int< N, C >::to_constant(), TREE_READONLY, TREE_SIDE_EFFECTS, lang_hooks_for_types::type_for_mode, lang_hooks::types, validize_mem(), VAR_P, virtual_outgoing_args_rtx, virtual_stack_dynamic_rtx, word_mode, and XEXP.

Referenced by emit_library_call_value_1(), emit_push_insn(), and store_one_arg().

◆ emit_storent_insn()

bool emit_storent_insn ( rtx to,
rtx from )
extern
Emits nontemporal store insn that moves FROM to TO.  Returns true if this
succeeded, false otherwise.   

References create_fixed_operand(), create_input_operand(), GET_MODE, maybe_expand_insn(), expand_operand::mode, and optab_handler().

Referenced by store_expr().

◆ expand_assignment()

void expand_assignment ( tree to,
tree from,
bool nontemporal )
extern
Expand an assignment that stores the value of FROM into TO.   
Expand an assignment that stores the value of FROM into TO.  If NONTEMPORAL
is true, try generating a nontemporal store.   

References ADDR_SPACE_GENERIC_P, adjust_address, aggregate_value_p(), as_a(), assign_stack_temp(), bits_to_bytes_round_down, BLOCK_OP_NORMAL, cfun, change_address(), COMPLETE_TYPE_P, COMPLEX_MODE_P, const0_rtx, convert_memory_address_addr_space(), convert_move(), convert_to_mode(), copy_blkmode_from_reg(), copy_blkmode_to_reg(), create_fixed_operand(), create_input_operand(), DECL_BIT_FIELD_TYPE, DECL_HARD_REGISTER, DECL_P, DECL_RTL, emit_block_move(), emit_block_move_via_libcall(), emit_group_load(), emit_group_move(), emit_group_store(), emit_move_insn(), expand_builtin_trap(), expand_expr(), expand_insn(), EXPAND_NORMAL, expand_normal(), EXPAND_SUM, EXPAND_WRITE, expr_size(), flip_storage_order(), force_not_mem(), force_operand(), force_subreg(), gcc_assert, gcc_checking_assert, gen_rtx_MEM(), get_address_mode(), get_alias_set(), get_bit_range(), GET_CODE, get_inner_reference(), GET_MODE, GET_MODE_ALIGNMENT, GET_MODE_BITSIZE(), GET_MODE_INNER, GET_MODE_PRECISION(), GET_MODE_SIZE(), GET_MODE_UNIT_BITSIZE, get_object_alignment(), handled_component_p(), highest_pow2_factor_for_target(), int_size_in_bytes(), known_eq, known_ge, known_le, lowpart_subreg(), maybe_emit_group_store(), maybe_gt, MEM_ALIGN, MEM_P, mem_ref_refers_to_non_mem_p(), MEM_VOLATILE_P, expand_operand::mode, NULL, NULL_RTX, NULL_TREE, num_trailing_bits, offset, offset_address(), operand_equal_p(), optab_handler(), optimize_bitfield_assignment_op(), POINTER_TYPE_P, pop_temp_slots(), preserve_temp_slots(), push_temp_slots(), read_complex_part(), REF_REVERSE_STORAGE_ORDER, refs_may_alias_p(), REG_P, set_mem_attributes_minus_bitpos(), shallow_copy_rtx(), simplify_gen_unary(), size_int, store_bit_field(), store_expr(), store_field(), SUBREG_P, subreg_promoted_mode(), SUBREG_PROMOTED_SIGN, SUBREG_PROMOTED_VAR_P, SUBREG_REG, subreg_unpromoted_mode(), targetm, TREE_CODE, TREE_OPERAND, TREE_TYPE, TYPE_ADDR_SPACE, TYPE_MODE, TYPE_SIZE, expand_operand::value, VAR_P, write_complex_part(), and XEXP.

Referenced by assign_parm_setup_reg(), expand_ACCESS_WITH_SIZE(), expand_asm_stmt(), expand_bitquery(), expand_call_stmt(), expand_DEFERRED_INIT(), expand_expr_real_1(), expand_gimple_stmt_1(), expand_LAUNDER(), store_constructor(), and ubsan_encode_value().

◆ expand_expr()

rtx expand_expr ( tree exp,
rtx target,
machine_mode mode,
enum expand_modifier modifier )
inline
Generate code for computing expression EXP.
An rtx for the computed value is returned.  The value is never null.
In the case of a void EXP, const0_rtx is returned.   

References exp(), expand_expr_real(), and NULL.

Referenced by addr_for_mem_ref(), assign_parms(), computation_cost(), expand_addsub_overflow(), expand_arith_overflow(), expand_asan_emit_allocas_unpoison(), expand_asm_stmt(), expand_assignment(), expand_BITINTTOFLOAT(), expand_builtin(), expand_builtin___clear_cache(), expand_builtin_assume_aligned(), expand_builtin_bswap(), expand_builtin_cexpi(), expand_builtin_copysign(), expand_builtin_eh_return(), expand_BUILTIN_EXPECT(), expand_builtin_expect(), expand_builtin_expect_with_probability(), expand_builtin_extend_pointer(), expand_builtin_extract_return_addr(), expand_builtin_fabs(), expand_builtin_frob_return_addr(), expand_builtin_int_roundingfn(), expand_builtin_int_roundingfn_2(), expand_builtin_interclass_mathfn(), expand_builtin_mathfn_3(), expand_builtin_mathfn_ternary(), expand_builtin_memory_chk(), expand_builtin_memset_args(), expand_builtin_powi(), expand_builtin_prefetch(), expand_builtin_set_thread_pointer(), expand_builtin_signbit(), expand_builtin_stpcpy_1(), expand_builtin_strlen(), expand_builtin_strnlen(), expand_builtin_strub_enter(), expand_builtin_strub_leave(), expand_builtin_strub_update(), expand_builtin_unop(), expand_builtin_va_copy(), expand_builtin_va_end(), expand_call(), expand_call_stmt(), expand_debug_expr(), expand_DIVMOD(), expand_expr_addr_expr_1(), expand_expr_force_mode(), expand_expr_real_1(), expand_expr_real_2(), expand_fn_using_insn(), expand_function_start(), expand_gather_load_optab_fn(), expand_gimple_stmt_1(), expand_GOACC_DIM_POS(), expand_GOACC_DIM_SIZE(), expand_GOMP_SIMT_ENTER_ALLOC(), expand_GOMP_SIMT_LANE(), expand_GOMP_SIMT_LAST_LANE(), expand_GOMP_SIMT_ORDERED_PRED(), expand_GOMP_SIMT_VOTE_ANY(), expand_GOMP_SIMT_XCHG_BFLY(), expand_GOMP_SIMT_XCHG_IDX(), expand_HWASAN_ALLOCA_UNPOISON(), expand_HWASAN_CHOOSE_TAG(), expand_HWASAN_SET_TAG(), expand_ifn_atomic_bit_test_and(), expand_ifn_atomic_compare_exchange(), expand_ifn_atomic_compare_exchange_into_call(), expand_ifn_atomic_op_fetch_cmp_0(), expand_load_lanes_optab_fn(), expand_mul_overflow(), expand_neg_overflow(), expand_operands(), expand_partial_load_optab_fn(), expand_partial_store_optab_fn(), expand_RAWMEMCHR(), expand_return(), expand_single_bit_test(), expand_SPACESHIP(), expand_speculation_safe_value(), expand_store_lanes_optab_fn(), expand_UADDC(), expand_UNIQUE(), expand_vec_cond_mask_optab_fn(), expand_vec_cond_optab_fn(), expand_vec_set_optab_fn(), expand_vector_ubsan_overflow(), expand_while_optab_fn(), expr_size(), get_builtin_sync_mem(), get_memory_rtx(), insert_value_copy_on_edge(), optimize_bitfield_assignment_op(), output_constant(), output_ttype(), read_complex_part(), reduce_to_bit_field_precision(), rtl_for_decl_init(), std_expand_builtin_va_start(), store_expr(), store_field(), store_one_arg(), update_nonlocal_goto_save_area(), and vector_compare_rtx().

◆ expand_expr_real()

rtx expand_expr_real ( tree exp,
rtx target,
machine_mode tmode,
enum expand_modifier modifier,
rtx * alt_rtl,
bool inner_reference_p )
extern
Work horses for expand_expr.   
expand_expr: generate code for computing expression EXP.
An rtx for the computed value is returned.  The value is never null.
In the case of a void EXP, const0_rtx is returned.

The value may be stored in TARGET if TARGET is nonzero.
TARGET is just a suggestion; callers must assume that
the rtx returned may not be the same as TARGET.

If TARGET is CONST0_RTX, it means that the value will be ignored.

If TMODE is not VOIDmode, it suggests generating the
result in mode TMODE.  But this is done only when convenient.
Otherwise, TMODE is ignored and the value generated in its natural mode.
TMODE is just a suggestion; callers must assume that
the rtx returned may not have mode TMODE.

Note that TARGET may have neither TMODE nor MODE.  In that case, it
probably will not be used.

If MODIFIER is EXPAND_SUM then when EXP is an addition
we can return an rtx of the form (MULT (REG ...) (CONST_INT ...))
or a nest of (PLUS ...) and (MINUS ...) where the terms are
products as above, or REG or MEM, or constant.
Ordinarily in such cases we would output mul or add instructions
and then return a pseudo reg containing the sum.

EXPAND_INITIALIZER is much like EXPAND_SUM except that
it also marks a label as absolutely required (it can't be dead).
It also makes a ZERO_EXTEND or SIGN_EXTEND instead of emitting extend insns.
This is used for outputting expressions used in initializers.

EXPAND_CONST_ADDRESS says that it is okay to return a MEM
with a constant address even if that address is not normally legitimate.
EXPAND_INITIALIZER and EXPAND_SUM also have this effect.

EXPAND_STACK_PARM is used when expanding to a TARGET on the stack for
a call parameter.  Such targets require special care as we haven't yet
marked TARGET so that it's safe from being trashed by libcalls.  We
don't want to use TARGET for anything but the final result;
Intermediate values must go elsewhere.   Additionally, calls to
emit_block_move will be flagged with BLOCK_OP_CALL_PARM.

If EXP is a VAR_DECL whose DECL_RTL was a MEM with an invalid
address, and ALT_RTL is non-NULL, then *ALT_RTL is set to the
DECL_RTL of the VAR_DECL.  *ALT_RTL is also set if EXP is a
COMPOUND_EXPR whose second argument is such a VAR_DECL, and so on
recursively.
If the result can be stored at TARGET, and ALT_RTL is non-NULL,
then *ALT_RTL is set to TARGET (before legitimziation).

If INNER_REFERENCE_P is true, we are expanding an inner reference.
In this case, we don't adjust a returned MEM rtx that wouldn't be
sufficiently aligned for its mode; instead, it's up to the caller
to deal with it afterwards.  This is used to make sure that unaligned
base objects for which out-of-bounds accesses are supported, for
example record types with trailing arrays, aren't realigned behind
the back of the caller.
The normal operating mode is to pass FALSE for this parameter.   

References CONST0_RTX, const0_rtx, exp(), expand_expr_real_1(), expand_operand::target, TREE_CODE, and TREE_TYPE.

Referenced by expand_expr(), expand_expr_real_1(), expand_expr_real_gassign(), expand_normal(), and store_expr().

◆ expand_expr_real_1()

rtx expand_expr_real_1 ( tree exp,
rtx target,
machine_mode tmode,
enum expand_modifier,
rtx * alt_rtl,
bool inner_reference_p )
extern

References add_to_hard_reg_set(), addr_for_mem_ref(), adjust_address, adjust_address_nv, AGGREGATE_TYPE_P, array_ref_low_bound(), as_a(), assign_stack_temp(), assign_stack_temp_for_type(), assign_temp(), bits_to_bytes_round_down, bits_to_bytes_round_up, bitsize_int, BLOCK_OP_CALL_PARM, BLOCK_OP_NORMAL, build1(), build2(), build3(), build_constructor(), build_decl(), build_int_cst(), build_zero_cst(), BUILT_IN_FRONTEND, CALL_EXPR_VA_ARG_PACK, CALL_FROM_THUNK_P, change_address(), separate_ops::code, compare_tree_int(), COMPLETE_OR_UNBOUND_ARRAY_TYPE_P, COMPLETE_TYPE_P, COMPLEX_MODE_P, const0_rtx, const_double_from_real_value(), CONST_FIXED_FROM_FIXED_VALUE, const_vector_from_tree(), CONSTANT_P, CONSTRUCTOR_APPEND_ELT, CONSTRUCTOR_ELTS, CONVERT_EXPR_CODE_P, convert_modes(), convert_move(), convert_to_mode(), convert_wider_int_to_float(), copy_rtx(), copy_to_reg(), crtl, ctor_for_folding(), curr_insn_location(), current_function_decl, currently_expanding_to_rtl, DECL_ALIGN, DECL_ARTIFICIAL, DECL_ATTRIBUTES, DECL_BIT_FIELD_TYPE, DECL_BUILT_IN_CLASS, DECL_EXTERNAL, decl_function_context(), DECL_IGNORED_P, DECL_INITIAL, DECL_MODE, lang_hooks::decl_printable_name, DECL_RTL, DECL_RTL_SET_P, DECL_SIZE, direct_load, do_pending_stack_adjust(), opt_mode< T >::else_blk(), emit_block_move(), emit_insn(), emit_label(), emit_move_insn(), error(), error_mark_node, opt_mode< T >::exists(), exp(), expand_assignment(), expand_builtin(), expand_call(), EXPAND_CONST_ADDRESS, expand_constructor(), expand_expr(), expand_expr_addr_expr(), expand_expr_addr_expr_1(), expand_expr_constant(), expand_expr_real(), expand_expr_real_1(), expand_expr_real_2(), expand_expr_real_gassign(), EXPAND_INITIALIZER, EXPAND_MEMORY, expand_misaligned_mem_ref(), EXPAND_NORMAL, expand_normal(), expand_shift(), EXPAND_STACK_PARM, EXPAND_SUM, EXPAND_WRITE, EXPR_LOCATION, EXTEND_BITINT, extract_bit_field(), flip_storage_order(), fndecl_built_in_p(), fold(), fold_convert_loc(), fold_read_from_constant_string(), fold_unary_loc(), FOR_EACH_CONSTRUCTOR_ELT, FOR_EACH_CONSTRUCTOR_VALUE, force_const_mem(), force_operand(), force_reg(), poly_int< N, C >::force_shwi(), g, gcc_assert, gcc_checking_assert, gcc_unreachable, gen_int_mode(), gen_label_rtx(), gen_lowpart, gen_lowpart_common(), gen_lowpart_SUBREG(), gen_raw_REG(), gen_reg_rtx(), gen_rtx_MEM(), get_address_mode(), get_callee_fndecl(), GET_CODE, get_def_for_expr(), get_gimple_for_ssa_name(), get_inner_reference(), GET_MODE, GET_MODE_ALIGNMENT, GET_MODE_BITSIZE(), GET_MODE_CLASS, GET_MODE_INNER, GET_MODE_PRECISION(), GET_MODE_SIZE(), get_object_alignment(), get_rtx_for_ssa_name(), get_subtarget(), gimple_assign_rhs1(), gimple_assign_rhs2(), gimple_call_fntype(), gimple_call_internal_p(), handled_component_p(), HARD_REGISTER_P, highest_pow2_factor(), i, identifier_to_locale(), immed_wide_int_const(), immediate_const_ctor_p(), int_expr_size(), int_mode_for_size(), int_size_in_bytes(), integer_onep(), integer_zerop(), INTEGRAL_TYPE_P, is_aligning_offset(), is_int_mode(), jumpif(), jumpifnot(), known_eq, known_ge, known_le, known_lt, LABEL_REF_NONLOCAL_P, label_rtx(), LAST_VIRTUAL_REGISTER, layout_decl(), bitint_info::limb_mode, limb_prec, separate_ops::location, lookup_attribute(), mark_reg_pointer(), MAX_FIXED_MODE_SIZE, maybe_gt, MEM_ADDR_SPACE, MEM_ALIGN, MEM_P, mem_ref_offset(), mem_ref_refers_to_non_mem_p(), MEM_VOLATILE_P, memory_address_addr_space(), memory_address_addr_space_p(), expand_operand::mode, mode_size, NULL, NULL_RTX, NULL_TREE, num_trailing_bits, OBJ_TYPE_REF_EXPR, offset, offset_address(), separate_ops::op0, separate_ops::op1, separate_ops::op2, optab_handler(), poly_int_cst_value(), poly_int_tree_p(), promote_decl_mode(), promote_function_mode(), promote_ssa_mode(), PUT_MODE(), read_complex_part(), REF_REVERSE_STORAGE_ORDER, REG_P, REGNO, replace_equiv_address(), SAVE_EXPR_RESOLVED_P, SCALAR_FLOAT_MODE_P, SCALAR_INT_MODE_P, SCALAR_INT_TYPE_MODE, SCOPE_FILE_SCOPE_P, SET_DECL_RTL, set_mem_addr_space(), set_mem_align(), set_mem_attributes(), set_mem_expr(), set_mem_size(), simplify_gen_binary(), size_diffop_loc(), size_int, sizetype, ssa_name, SSA_NAME_DEF_STMT, SSA_NAME_IS_DEFAULT_DEF, SSA_NAME_VAR, stmt_is_replaceable_p(), store_constructor(), store_expr(), SUBREG_PROMOTED_SET, SUBREG_PROMOTED_VAR_P, targetm, tcc_binary, tcc_comparison, tcc_unary, wi::to_poly_offset(), wi::to_wide(), TREE_ADDRESSABLE, TREE_CODE, TREE_CODE_CLASS, TREE_CODE_LENGTH, tree_fits_uhwi_p(), TREE_FIXED_CST, TREE_IMAGPART, tree_int_cst_equal(), TREE_INT_CST_LOW, TREE_OPERAND, tree_output_constant_def(), TREE_READONLY, TREE_REAL_CST, TREE_REALPART, TREE_SIDE_EFFECTS, TREE_STATIC, TREE_STRING_LENGTH, TREE_STRING_POINTER, TREE_THIS_VOLATILE, TREE_TYPE, TREE_USED, TREE_VALUE, separate_ops::type, type(), TYPE_ADDR_SPACE, TYPE_ALIGN, lang_hooks_for_types::type_for_mode, type_has_mode_precision_p(), TYPE_MODE, TYPE_PRECISION, TYPE_REVERSE_STORAGE_ORDER, TYPE_SIZE, TYPE_UNSIGNED, lang_hooks::types, profile_probability::uninitialized(), use_anchored_address(), validize_mem(), VAR_P, vec_alloc(), VECTOR_CST_ELT, VECTOR_CST_NELTS, VECTOR_MODE_P, VECTOR_TYPE_P, VL_EXP_CLASS_P, warning_at(), and XEXP.

Referenced by expand_expr_real(), and expand_expr_real_1().

◆ expand_expr_real_2()

rtx expand_expr_real_2 ( const_sepops ops,
rtx target,
machine_mode tmode,
enum expand_modifier )
extern

References add_cost(), adjust_address, adjust_address_nv, ALL_FIXED_POINT_MODE_P, arg_pointer_rtx, assign_temp(), BITS_PER_WORD, build_int_cst(), can_conditionally_move_p(), CASE_CONVERT, choose_mult_variant(), separate_ops::code, const0_rtx, const1_rtx, CONST_INT_P, CONSTANT_P, constm1_rtx, CONVERT_EXPR_CODE_P, convert_modes(), convert_move(), convert_to_mode(), copy_rtx(), copy_to_mode_reg(), algorithm::cost, create_convert_operand_from(), create_input_operand(), create_output_operand(), DECL_RTL, do_compare_rtx_and_jump(), do_pending_stack_adjust(), do_store_flag(), emit_barrier(), emit_conditional_move(), emit_insn(), emit_jump_insn(), emit_label(), emit_move_insn(), end_sequence(), error_mark_node, expand_abs(), expand_and(), expand_binop(), expand_cond_expr_using_cmove(), expand_expr(), expand_expr_divmod(), expand_fix(), expand_fixed_convert(), expand_float(), EXPAND_INITIALIZER, expand_insn(), expand_mult(), expand_mult_highpart(), expand_mult_highpart_adjust(), EXPAND_NORMAL, expand_normal(), expand_operands(), EXPAND_STACK_PARM, EXPAND_SUM, expand_ternary_op(), expand_unop(), expand_variable_shift(), expand_vec_perm_const(), expand_vec_perm_var(), expand_vec_series_expr(), expand_vector_broadcast(), expand_widen_pattern_expr(), expand_widening_mult(), find_widening_optab_handler, fold_build1, fold_convert_loc(), force_lowpart_subreg(), force_operand(), force_reg(), frame_pointer_rtx, gcc_assert, gcc_unreachable, gen_highpart(), GEN_INT, gen_int_mode(), gen_label_rtx(), gen_reg_rtx(), GET_CODE, get_def_for_expr(), get_gimple_rhs_class(), get_insns(), GET_MODE, GET_MODE_2XWIDER_MODE(), GET_MODE_BITSIZE(), GET_MODE_CLASS, GET_MODE_INNER, GET_MODE_PRECISION(), GET_MODE_SIZE(), get_subtarget(), gimple_assign_rhs1(), gimple_assign_rhs2(), gimple_assign_rhs_code(), GIMPLE_BINARY_RHS, GIMPLE_TERNARY_RHS, GIMPLE_UNARY_RHS, have_insn_for(), HWI_COMPUTABLE_MODE_P(), immed_wide_int_const(), int_fits_type_p(), INTEGRAL_TYPE_P, INTVAL, is_gimple_assign(), jumpifnot(), jumpifnot_1(), separate_ops::location, lowpart_subreg(), wi::mask(), MEM_P, MEM_VOLATILE_P, expand_operand::mode, mul_cost(), neg_cost(), negate_rtx(), NO_DEFER_POP, NULL, NULL_RTX, OK_DEFER_POP, separate_ops::op0, separate_ops::op1, separate_ops::op2, operand_equal_p(), algorithm::ops, optab_default, optab_for_tree_code(), optab_handler(), OPTAB_LIB_WIDEN, OPTAB_WIDEN, optimize_insn_for_speed_p(), plus_constant(), POINTER_TYPE_P, ptr_mode, really_constant_p(), REDUCE_BIT_FIELD, reg_overlap_mentioned_p(), REG_P, REGNO, safe_from_p(), SCALAR_INT_MODE_P, SCALAR_INT_TYPE_MODE, seq_cost(), set_mem_attributes(), wi::shwi(), simplify_gen_binary(), simplify_gen_subreg(), sizetype, SSA_NAME_DEF_STMT, ssizetype, stack_pointer_rtx, start_sequence(), store_bit_field(), store_expr(), store_field(), subreg_highpart_offset(), expand_operand::target, targetm, TREE_ADDRESSABLE, TREE_CODE, TREE_CONSTANT, tree_fits_shwi_p(), TREE_INT_CST_LOW, TREE_OPERAND, tree_to_poly_uint64(), tree_to_shwi(), tree_to_uhwi(), tree_to_vec_perm_builder(), TREE_TYPE, separate_ops::type, type(), TYPE_ADDR_SPACE, type_has_mode_precision_p(), TYPE_MODE, TYPE_PRECISION, TYPE_REVERSE_STORAGE_ORDER, TYPE_SATURATING, TYPE_SIZE, TYPE_UNSIGNED, TYPE_VECTOR_SUBPARTS(), profile_probability::uninitialized(), expand_operand::value, VAR_P, VECTOR_BOOLEAN_TYPE_P, VECTOR_MODE_P, VECTOR_TYPE_P, void_type_node, VOID_TYPE_P, word_mode, write_complex_part(), and XEXP.

Referenced by expand_arith_overflow(), expand_DIVMOD(), expand_expr_real_1(), expand_expr_real_gassign(), expand_mul_overflow(), expand_vector_ubsan_overflow(), maybe_optimize_mod_cmp(), and maybe_optimize_pow2p_mod_cmp().

◆ expand_expr_real_gassign()

◆ expand_normal()

rtx expand_normal ( tree exp)
inline

References exp(), expand_expr_real(), EXPAND_NORMAL, NULL, and NULL_RTX.

Referenced by add_mask_and_len_args(), asan_emit_stack_protection(), copy_blkmode_to_reg(), do_compare_and_jump(), do_jump(), do_jump_by_parts_equality(), do_jump_by_parts_greater(), expand_addsub_overflow(), expand_assignment(), expand_BITINTTOFLOAT(), expand_builtin(), expand_builtin_adjust_descriptor(), expand_builtin_adjust_trampoline(), expand_builtin_alloca(), expand_builtin_atomic_compare_exchange(), expand_builtin_cexpi(), expand_builtin_copysign(), expand_builtin_feclear_feraise_except(), expand_builtin_init_descriptor(), expand_builtin_init_dwarf_reg_sizes(), expand_builtin_init_trampoline(), expand_builtin_int_roundingfn(), expand_builtin_issignaling(), expand_builtin_mathfn_ternary(), expand_builtin_memcmp(), expand_builtin_memory_copy_args(), expand_builtin_memset_args(), expand_builtin_nonlocal_goto(), expand_builtin_prefetch(), expand_builtin_signbit(), expand_builtin_sincos(), expand_builtin_stpcpy_1(), expand_builtin_strcmp(), expand_builtin_strncmp(), expand_call(), expand_computed_goto(), expand_cond_expr_using_cmove(), expand_DIVMOD(), expand_DIVMODBITINT(), expand_expr_real_1(), expand_expr_real_2(), expand_FLOATTOBITINT(), expand_fn_using_insn(), expand_gather_load_optab_fn(), expand_GOMP_SIMT_ENTER_ALLOC(), expand_GOMP_SIMT_EXIT(), expand_GOMP_SIMT_LAST_LANE(), expand_GOMP_SIMT_ORDERED_PRED(), expand_GOMP_SIMT_VOTE_ANY(), expand_GOMP_SIMT_XCHG_BFLY(), expand_GOMP_SIMT_XCHG_IDX(), expand_HWASAN_MARK(), expand_HWASAN_SET_TAG(), expand_load_lanes_optab_fn(), expand_mul_overflow(), expand_MULBITINT(), expand_neg_overflow(), expand_partial_store_optab_fn(), expand_POPCOUNT(), expand_RAWMEMCHR(), expand_return(), expand_scatter_store_optab_fn(), expand_SPACESHIP(), expand_stack_restore(), expand_store_lanes_optab_fn(), expand_UADDC(), expand_UNIQUE(), expand_variable_shift(), expand_vec_cond_mask_optab_fn(), expand_vec_cond_optab_fn(), expand_vec_set_optab_fn(), expand_vector_ubsan_overflow(), expand_while_optab_fn(), fold_builtin_atomic_always_lock_free(), get_memmodel(), maybe_optimize_mod_cmp(), maybe_optimize_pow2p_mod_cmp(), precompute_arguments(), precompute_register_parameters(), rtx_for_function_call(), stack_protect_epilogue(), stack_protect_prologue(), store_constructor(), store_field(), try_casesi(), and try_tablejump().

◆ expand_operands()

void expand_operands ( tree exp0,
tree exp1,
rtx target,
rtx * op0,
rtx * op1,
enum expand_modifier modifier )
extern
Subroutine of expand_expr.  Expand the two operands of a binary
expression EXP0 and EXP1 placing the results in OP0 and OP1.
The value may be stored in TARGET if TARGET is nonzero.  The
MODIFIER argument is as documented by expand_expr.   

References copy_rtx(), expand_expr(), NULL_RTX, operand_equal_p(), safe_from_p(), and expand_operand::target.

Referenced by do_store_flag(), expand_cond_expr_using_cmove(), and expand_expr_real_2().

◆ expr_size()

rtx expr_size ( tree exp)
extern
rtl.h and tree.h were included.   
Return an rtx for the size in bytes of the value of an expr.   
Return an rtx for the size in bytes of the value of EXP.   

References exp(), expand_expr(), EXPAND_NORMAL, gcc_assert, NULL_RTX, sizetype, SUBSTITUTE_PLACEHOLDER_IN_EXPR, TREE_CODE, tree_expr_size(), TREE_OPERAND, and TYPE_MODE.

Referenced by do_compare_and_jump(), emit_partition_copy(), expand_assignment(), expand_constructor(), initialize_argument_information(), store_constructor(), and store_expr().

◆ force_operand()

rtx force_operand ( rtx value,
rtx target )
extern
Given an rtx that may include add and multiply operations,
generate them as insns and return a pseudo-reg containing the value.
Useful after calling expand_expr with 1 as sum_ok.   
Given an rtx VALUE that may contain additions and multiplications, return
an equivalent value that just refers to a register, memory, or constant.
This is done by generating instructions to perform the arithmetic and
returning a pseudo-register containing the value.

The returned value may be a REG, SUBREG, MEM or constant.   

References ARITHMETIC_P, CONST_INT_P, CONSTANT_P, convert_move(), emit_move_insn(), expand_divmod(), expand_fix(), expand_float(), expand_mult(), expand_simple_binop(), expand_simple_unop(), FLOAT_MODE_P, force_operand(), force_reg(), gen_reg_rtx(), GET_CODE, GET_MODE, get_subtarget(), INTEGRAL_MODE_P, MEM_P, negate_rtx(), NULL_RTX, OPTAB_LIB_WIDEN, paradoxical_subreg_p(), pic_offset_table_rtx, REG_P, simplify_gen_subreg(), SUBREG_BYTE, SUBREG_REG, expand_operand::target, UNARY_P, expand_operand::value, VIRTUAL_REGISTER_P, and XEXP.

Referenced by add_test(), allocate_dynamic_stack_space(), anti_adjust_stack_and_probe(), combine_var_copies_in_loop_exit(), compare_and_jump_seq(), compute_stack_clash_protection_loop_data(), copy_to_mode_reg(), copy_to_reg(), doloop_modify(), emit_block_cmp_via_loop(), emit_block_move_via_loop(), emit_block_move_via_oriented_loop(), emit_library_call_value_1(), expand_assignment(), expand_builtin_adjust_descriptor(), expand_builtin_apply_args_1(), expand_builtin_memory_copy_args(), expand_builtin_memset_args(), expand_builtin_setjmp_setup(), expand_builtin_stpcpy_1(), expand_builtin_strncpy(), expand_builtin_strub_leave(), expand_call(), expand_divmod(), expand_expr_addr_expr_1(), expand_expr_real_1(), expand_expr_real_2(), expand_gimple_stmt_1(), expand_movstr(), expand_mult_const(), expand_mult_highpart_adjust(), expmed_mult_highpart(), force_operand(), force_reg(), get_dynamic_stack_size(), insert_base_initialization(), instantiate_virtual_regs_in_insn(), memory_address_addr_space(), probe_stack_range(), round_push(), rtl_lv_add_condition_to_bb(), split_iv(), store_expr(), try_store_by_multiple_pieces(), and unroll_loop_runtime_iterations().

◆ gen_group_rtx()

rtx gen_group_rtx ( rtx orig)
extern
Generate a non-consecutive group of registers represented by a PARALLEL.   
Generate a PARALLEL rtx for a new non-consecutive group of registers from
ORIG, where ORIG is a non-consecutive group of registers represented by
a PARALLEL.  The clone is identical to the original except in that the
original set of registers is replaced by a new set of pseudo registers.
The new set has the same modes as the original set.   

References gcc_assert, gen_reg_rtx(), gen_rtvec_v(), gen_rtx_EXPR_LIST(), GET_CODE, GET_MODE, i, expand_operand::mode, offset, XEXP, XVECEXP, and XVECLEN.

Referenced by expand_function_start().

◆ gen_move_insn()

◆ get_bit_range()

void get_bit_range ( poly_uint64 * bitstart,
poly_uint64 * bitend,
tree exp,
poly_int64 * bitpos,
tree * offset )
extern
Extract the accessible bit-range from a COMPONENT_REF.   
In the C++ memory model, consecutive bit fields in a structure are
considered one memory location.

Given a COMPONENT_REF EXP at position (BITPOS, OFFSET), this function
returns the bit range of consecutive bits in which this COMPONENT_REF
belongs.  The values are returned in *BITSTART and *BITEND.  *BITPOS
and *OFFSET may be adjusted in the process.

If the access does not need to be restricted, 0 is returned in both
*BITSTART and *BITEND.   

References DECL_BIT_FIELD_REPRESENTATIVE, DECL_FIELD_BIT_OFFSET, DECL_FIELD_OFFSET, DECL_SIZE, exp(), gcc_assert, get_inner_reference(), handled_component_p(), maybe_gt, NULL_TREE, offset, poly_int_tree_p(), size_binop, size_int, TREE_CODE, TREE_OPERAND, tree_to_poly_uint64(), and tree_to_uhwi().

Referenced by expand_assignment(), and optimize_bit_field_compare().

◆ get_personality_function()

rtx get_personality_function ( tree decl)

◆ highest_pow2_factor()

unsigned HOST_WIDE_INT highest_pow2_factor ( const_tree exp)
extern
Return the highest power of two that EXP is known to be a multiple of.
This is used in updating alignment of MEMs in array references.   

References exp(), HOST_BITS_PER_WIDE_INT, HOST_WIDE_INT_1U, and tree_ctz().

Referenced by dr_analyze_innermost(), expand_expr_real_1(), get_base_for_alignment_1(), highest_pow2_factor_for_target(), store_constructor(), store_expr(), and vect_find_stmt_data_reference().

◆ immediate_const_ctor_p()

bool immediate_const_ctor_p ( const_tree ctor,
unsigned int words )
extern
Return true if constructor CTOR is simple enough to be materialized
in an integer mode register.  Limit the size to WORDS words, which
is 1 by default.   

References CONSTRUCTOR_NELTS, initializer_constant_valid_for_bitfield_p(), int_expr_size(), TREE_ADDRESSABLE, TREE_CODE, TREE_CONSTANT, and TREE_TYPE.

Referenced by emit_push_insn(), expand_expr_real_1(), and load_register_parameters().

◆ init_expr()

◆ init_expr_target()

void init_expr_target ( void )
extern
This is run during target initialization to set up which modes can be
used directly in memory and to initialize the block move optab.   
This is run to set up which modes can be used
directly in memory and to initialize the block move optab.  It is run
at the beginning of compilation and when the target is reinitialized.   

References as_a(), can_extend_p(), direct_load, direct_store, float_extend_from_mem, FOR_EACH_MODE_IN_CLASS, FOR_EACH_MODE_UNTIL, frame_pointer_rtx, gen_raw_REG(), gen_rtx_MEM(), gen_rtx_REG(), insn_operand_matches(), LAST_VIRTUAL_REGISTER, NULL_RTX, PATTERN(), PUT_MODE(), recog(), opt_mode< T >::require(), rtx_alloc(), SET_DEST, set_mode_and_regno(), SET_SRC, stack_pointer_rtx, targetm, and word_mode.

Referenced by backend_init_target().

◆ int_expr_size()

HOST_WIDE_INT int_expr_size ( const_tree exp)
extern
Return a wide integer for the size in bytes of the value of EXP, or -1
if the size can vary or is larger than an integer.   

References exp(), gcc_assert, TREE_CODE, tree_expr_size(), tree_fits_shwi_p(), TREE_OPERAND, and tree_to_shwi().

Referenced by emit_push_insn(), expand_constructor(), expand_expr_real_1(), immediate_const_ctor_p(), load_register_parameters(), and store_expr().

◆ maybe_emit_group_store()

rtx maybe_emit_group_store ( rtx x,
tree type )
extern
Return a form of X that does not use a PARALLEL.  TYPE is the type
of the value stored in X.   

References emit_group_store(), gcc_checking_assert, gen_reg_rtx(), GET_CODE, GET_MODE, int_size_in_bytes(), expand_operand::mode, and TYPE_MODE.

Referenced by expand_assignment(), expand_builtin_int_roundingfn(), and expand_builtin_int_roundingfn_2().

◆ maybe_optimize_mod_cmp()

enum tree_code maybe_optimize_mod_cmp ( enum tree_code code,
tree * arg0,
tree * arg1 )
extern
Attempt to optimize unsigned (X % C1) == C2 (or (X % C1) != C2).
If C1 is odd to:
(X - C2) * C3 <= C4 (or >), where
C3 is modular multiplicative inverse of C1 and 1<<prec and
C4 is ((1<<prec) - 1) / C1 or ((1<<prec) - 1) / C1 - 1 (the latter
if C2 > ((1<<prec) - 1) % C1).
If C1 is even, S = ctz (C1) and C2 is 0, use
((X * C3) r>> S) <= C4, where C3 is modular multiplicative
inverse of C1>>S and 1<<prec and C4 is (((1<<prec) - 1) / (C1>>S)) >> S.

For signed (X % C1) == 0 if C1 is odd to (all operations in it
unsigned):
(X * C3) + C4 <= 2 * C4, where
C3 is modular multiplicative inverse of (unsigned) C1 and 1<<prec and
C4 is ((1<<(prec - 1) - 1) / C1).
If C1 is even, S = ctz(C1), use
((X * C3) + C4) r>> S <= (C4 >> (S - 1))
where C3 is modular multiplicative inverse of (unsigned)(C1>>S) and 1<<prec
and C4 is ((1<<(prec - 1) - 1) / (C1>>S)) & (-1<<S).

See the Hacker's Delight book, section 10-17.   

References a, b, wi::bit_and(), build_int_cst(), separate_ops::code, compare_tree_int(), wi::ctz(), wi::divmod_trunc(), do_pending_stack_adjust(), emit_insn(), end_sequence(), expand_expr_real_2(), EXPAND_NORMAL, expand_normal(), fold_build2_loc(), fold_convert, fold_convert_loc(), FOR_EACH_IMM_USE_FAST, wide_int_storage::from(), gcc_checking_assert, get_def_for_expr(), get_insns(), GET_MODE_BITSIZE(), get_range_pos_neg(), gimple_assign_rhs1(), gimple_assign_rhs2(), gimple_assign_rhs_code(), gimple_bb(), gimple_location(), wi::gtu_p(), integer_pow2p(), integer_zerop(), is_a(), is_gimple_assign(), separate_ops::location, wi::lrshift(), wi::lshift(), make_tree(), wi::mask(), maybe_optimize_pow2p_mod_cmp(), wi::mod_inv(), NULL, NULL_RTX, NULL_TREE, separate_ops::op0, separate_ops::op1, separate_ops::op2, operand_equal_p(), optimize_insn_for_speed_p(), rtx_cost(), seq_cost(), shift, wi::shifted_mask(), SIGNED, start_sequence(), wi::to_wide(), TREE_CODE, tree_int_cst_le(), tree_int_cst_sgn(), TREE_TYPE, separate_ops::type, TYPE_MODE, TYPE_PRECISION, TYPE_UNSIGNED, wi::udiv_trunc(), wi::umod_trunc(), UNSIGNED, unsigned_type_for(), USE_STMT, and wide_int_to_tree().

Referenced by do_store_flag(), and expand_gimple_cond().

◆ maybe_optimize_sub_cmp_0()

◆ mem_ref_refers_to_non_mem_p()

bool mem_ref_refers_to_non_mem_p ( tree ref)
extern
Returns true if REF refers to an object that does not
reside in memory and has non-BLKmode.   

References non_mem_decl_p(), TREE_CODE, and TREE_OPERAND.

Referenced by expand_assignment(), expand_DEFERRED_INIT(), and expand_expr_real_1().

◆ move_block_from_reg()

void move_block_from_reg ( int regno,
rtx x,
int nregs )
extern
Copy all or part of a BLKmode value X out of registers starting at REGNO.
The number of registers to be filled is NREGS.   

References delete_insns_since(), emit_insn(), emit_move_insn(), gcc_assert, GEN_INT, gen_rtx_REG(), get_last_insn(), i, last, operand_subword(), targetm, and word_mode.

Referenced by assign_parm_adjust_entry_rtl(), and assign_parm_setup_block().

◆ move_block_to_reg()

void move_block_to_reg ( int regno,
rtx x,
int nregs,
machine_mode mode )
extern
Copy all or part of a value X into registers starting at REGNO.
The number of registers to be filled is NREGS.   

References CONSTANT_P, delete_insns_since(), emit_insn(), emit_move_insn(), force_const_mem(), GEN_INT, gen_rtx_REG(), get_last_insn(), i, last, expand_operand::mode, operand_subword_force(), targetm, validize_mem(), and word_mode.

Referenced by emit_push_insn(), and load_register_parameters().

◆ non_mem_decl_p()

bool non_mem_decl_p ( tree base)
extern
Returns true if BASE is a DECL that does not reside in memory and
has non-BLKmode.  DECL_RTL must not be a MEM; if
DECL_RTL was not set yet, return false.   

References DECL_MODE, DECL_P, DECL_RTL, DECL_RTL_SET_P, MEM_P, and TREE_ADDRESSABLE.

Referenced by expand_DEFERRED_INIT(), and mem_ref_refers_to_non_mem_p().

◆ push_block()

rtx push_block ( rtx size,
poly_int64 extra,
int below )
extern
Push a block of length SIZE (perhaps variable)
and return an rtx to address the beginning of the block.   
Pushing data onto the stack.   
Push a block of length SIZE (perhaps variable)
and return an rtx to address the beginning of the block.
The value may be virtual_outgoing_args_rtx.

EXTRA is the number of bytes of padding to push in addition to SIZE.
BELOW nonzero means this padding comes at low addresses;
otherwise, the padding comes at high addresses.   

References anti_adjust_stack(), CONSTANT_P, convert_modes(), copy_to_mode_reg(), expand_binop(), gen_int_mode(), known_eq, memory_address, NARROWEST_INT_MODE, negate_rtx(), OPTAB_LIB_WIDEN, plus_constant(), poly_int_rtx_p(), ptr_mode, REG_P, STACK_GROWS_DOWNWARD, and virtual_outgoing_args_rtx.

Referenced by emit_library_call_value_1(), emit_push_insn(), and expand_call().

◆ read_complex_part()

rtx read_complex_part ( rtx cplx,
bool imag_p )
extern

◆ safe_from_p()

bool safe_from_p ( const_rtx x,
tree exp,
int top_p )
extern
Subroutine of expand_expr: return true iff there is no way that
EXP can reference X, which is being modified.  TOP_P is nonzero if this
call is going to be used to determine whether we need a temporary
for EXP, as opposed to a recursive call to this function.

It is always safe for this routine to return false since it merely
searches for optimization opportunities.   

References alias_sets_conflict_p(), COMPLETE_TYPE_P, CONSTRUCTOR_ELTS, DECL_EXPR_DECL, DECL_INITIAL, DECL_P, DECL_RTL, DECL_RTL_IF_SET, DECL_RTL_SET_P, exp(), FOR_EACH_VEC_SAFE_ELT, gcc_unreachable, get_alias_set(), GET_CODE, GET_MODE, i, constructor_elt::index, MEM_ALIAS_SET, MEM_P, NULL_TREE, REG_P, REGNO, rtx_equal_p(), safe_from_p(), staticp(), SUBREG_REG, tcc_binary, tcc_comparison, tcc_constant, tcc_declaration, tcc_exceptional, tcc_expression, tcc_reference, tcc_statement, tcc_type, tcc_unary, tcc_vl_exp, TREE_CHAIN, TREE_CODE, TREE_CODE_CLASS, TREE_OPERAND, TREE_OPERAND_LENGTH, TREE_STATIC, TREE_TYPE, TREE_VALUE, true_dependence(), TYPE_ARRAY_MAX_SIZE, TYPE_SIZE, constructor_elt::value, virtual_outgoing_args_rtx, and XEXP.

Referenced by expand_builtin_fabs(), expand_constructor(), expand_expr_real_2(), expand_operands(), and safe_from_p().

◆ set_storage_via_libcall()

rtx set_storage_via_libcall ( rtx object,
rtx size,
rtx val,
bool tailcall )
extern
The same, but always output an library call.   
A subroutine of clear_storage.  Expand a call to memset.
Return the return value of memset, 0 otherwise.   

References build_call_expr(), builtin_decl_implicit(), CALL_EXPR_TAILCALL, CONST_INT_P, convert_to_mode(), copy_addr_to_reg(), copy_to_mode_reg(), expand_call(), integer_type_node, make_tree(), NULL_RTX, ptr_type_node, sizetype, TYPE_MODE, and XEXP.

Referenced by clear_storage_hints().

◆ set_storage_via_setmem()

bool set_storage_via_setmem ( rtx object,
rtx size,
rtx val,
unsigned int align,
unsigned int expected_align,
HOST_WIDE_INT expected_size,
unsigned HOST_WIDE_INT min_size,
unsigned HOST_WIDE_INT max_size,
unsigned HOST_WIDE_INT probable_max_size )
extern

◆ store_by_pieces()

rtx store_by_pieces ( rtx to,
unsigned HOST_WIDE_INT len,
by_pieces_constfn constfun,
void * constfundata,
unsigned int align,
bool memsetp,
memop_ret retmode )
extern
Generate several move instructions to store LEN bytes generated by
CONSTFUN to block TO.  (A MEM rtx with BLKmode).  CONSTFUNDATA is a
pointer which will be passed as argument in every CONSTFUN call.
ALIGN is maximum alignment we can assume.
MEMSETP is true if this is a real memset/bzero, not a copy.
Returns TO + LEN.   
Generate several move instructions to store LEN bytes generated by
CONSTFUN to block TO.  (A MEM rtx with BLKmode).  CONSTFUNDATA is a
pointer which will be passed as argument in every CONSTFUN call.
ALIGN is maximum alignment we can assume.  MEMSETP is true if this is
a memset operation and false if it's a copy of a constant string.
Return value is based on RETMODE argument.   

References gcc_assert, optimize_insn_for_speed_p(), RETURN_BEGIN, RETURN_END_MINUS_ONE, SET_BY_PIECES, STORE_BY_PIECES, and targetm.

Referenced by asan_emit_stack_protection(), expand_builtin_memory_copy_args(), expand_builtin_memset_args(), expand_builtin_strncpy(), store_expr(), and try_store_by_multiple_pieces().

◆ store_constructor()

void store_constructor ( tree exp,
rtx target,
int cleared,
poly_int64 size,
bool reverse )
extern
Store the value of constructor EXP into the rtx TARGET.
TARGET is either a REG or a MEM; we know it cannot conflict, since
safe_from_p has been called.
CLEARED is true if TARGET is known to have been zero'd.
SIZE is the number of bytes of TARGET we are allowed to modify: this
may not be the same as the size of EXP if we are assigning to a field
which has been packed to exclude padding bits.
If REVERSE is true, the store is to be done in reverse order.   

References adjust_address, bit_position(), BITS_PER_WORD, BLOCK_OP_NORMAL, build2(), build_decl(), build_int_cst(), clear_storage(), CONST0_RTX, CONSTRUCTOR_ELT, CONSTRUCTOR_ELTS, CONSTRUCTOR_NELTS, convert_move(), convert_optab_handler(), copy_rtx(), count, create_input_operand(), create_output_operand(), DECL_BIT_FIELD, DECL_FIELD_OFFSET, DECL_MODE, DECL_NONADDRESSABLE_P, DECL_SIZE, do_pending_stack_adjust(), emit_clobber(), emit_insn(), emit_jump(), emit_label(), emit_move_insn(), exp(), expand_assignment(), expand_binop(), expand_insn(), expand_normal(), EXPR_LOCATION, expr_size(), fields_length(), fold_build2, fold_convert, FOR_EACH_CONSTRUCTOR_ELT, FOR_EACH_CONSTRUCTOR_VALUE, force_reg(), gcc_assert, gcc_unreachable, GEN_INT, gen_int_mode(), gen_label_rtx(), gen_reg_rtx(), get_alias_set(), GET_MODE, GET_MODE_BITSIZE(), GET_MODE_CLASS, GET_MODE_INNER, GET_MODE_PRECISION(), GET_MODE_SIZE(), highest_pow2_factor(), HOST_WIDE_INT_1U, i, constructor_elt::index, initializer_zerop(), int_bit_position(), int_size_in_bytes(), integer_one_node, integer_type_node, poly_int< N, C >::is_constant(), jumpif(), known_eq, known_gt, known_le, wi::mask(), maybe_gt, MEM_ALIAS_SET, MEM_KEEP_ALIAS_SET_P, MEM_P, expand_operand::mode, mostly_zeros_p(), NULL, NULL_TREE, offset, offset_address(), optab_handler(), OPTAB_WIDEN, poly_int_tree_p(), promote_decl_mode(), REG_P, REGMODE_NATURAL_SIZE, rtvec_alloc(), RTVEC_ELT, rtx_equal_p(), SCALAR_INT_MODE_P, SET_DECL_RTL, size_binop, ssize_int, ssizetype, store_constructor(), store_constructor_field(), store_expr(), expand_operand::target, poly_int< N, C >::to_constant(), TREE_CODE, tree_fits_shwi_p(), tree_fits_uhwi_p(), TREE_OPERAND, TREE_SIDE_EFFECTS, TREE_STATIC, tree_to_shwi(), tree_to_uhwi(), TREE_TYPE, TYPE_DOMAIN, lang_hooks_for_types::type_for_mode, TYPE_MAX_VALUE, TYPE_MIN_VALUE, TYPE_MODE, TYPE_NONALIASED_COMPONENT, TYPE_PRECISION, TYPE_REVERSE_STORAGE_ORDER, TYPE_SIZE, TYPE_SIZE_UNIT, TYPE_UNSIGNED, TYPE_VECTOR_SUBPARTS(), lang_hooks::types, uniform_vector_p(), profile_probability::uninitialized(), constructor_elt::value, expand_operand::value, vec_safe_iterate(), VECTOR_BOOLEAN_TYPE_P, vector_element_bits(), VECTOR_MODE_P, VECTOR_TYPE_P, wide_int_to_tree(), word_mode, and WORD_REGISTER_OPERATIONS.

Referenced by emit_push_insn(), expand_constructor(), expand_expr_real_1(), load_register_parameters(), store_constructor(), store_constructor_field(), and store_field().

◆ store_expr()

rtx store_expr ( tree exp,
rtx target,
int call_param_p,
bool nontemporal,
bool reverse )
extern
Generate code for computing expression EXP,
and storing the value into TARGET.
If SUGGEST_REG is nonzero, copy the value through a register
and return that register, if that is possible.   
Generate code for computing expression EXP,
and storing the value into TARGET.

If the mode is BLKmode then we may return TARGET itself.
It turns out that in BLKmode it doesn't cause a problem.
because C has no operators that could combine two different
assignments into the same BLKmode object with different values
with no sequence point.  Will other languages need this to
be more thorough?

If CALL_PARAM_P is nonzero, this is a store into a call param on the
stack, and block moves may need to be treated specially.

If NONTEMPORAL is true, try using a nontemporal store instruction.

If REVERSE is true, the store is to be done in reverse order.   

References adjust_address, adjust_address_1(), BLOCK_OP_CALL_PARM, BLOCK_OP_NORMAL, build_array_type(), build_index_type(), can_store_by_pieces(), change_address(), clear_storage(), const0_rtx, CONST_INT_P, CONSTANT_P, convert_modes(), convert_move(), convert_to_mode(), copy_blkmode_from_reg(), copy_node(), curr_insn_location(), do_pending_stack_adjust(), emit_barrier(), emit_block_move(), emit_cmp_and_jump_insns(), emit_group_load(), emit_group_move(), emit_group_store(), emit_jump_insn(), emit_label(), emit_move_insn(), emit_storent_insn(), exp(), expand_binop(), expand_expr(), expand_expr_real(), EXPAND_NORMAL, EXPAND_STACK_PARM, expr_size(), flip_storage_order(), fold_convert_loc(), force_operand(), gcc_assert, gcc_unreachable, GEN_INT, gen_label_rtx(), get_address_mode(), GET_CODE, GET_MODE, GET_MODE_BITSIZE(), GET_MODE_CLASS, GET_MODE_PRECISION(), highest_pow2_factor(), int_expr_size(), int_size_in_bytes(), integer_zerop(), INTEGRAL_TYPE_P, INTVAL, jumpifnot(), known_eq, make_tree(), MEM_ADDR_SPACE, MEM_ALIGN, MEM_P, mems_same_for_tbaa_p(), NO_DEFER_POP, NULL, NULL_RTX, offset_address(), OK_DEFER_POP, OPTAB_LIB_WIDEN, plus_constant(), poly_int_rtx_p(), REG_P, RETURN_BEGIN, RETURN_END, rtx_equal_p(), rtx_to_poly_int64(), SCALAR_INT_MODE_P, side_effects_p(), signed_or_unsigned_type_for(), simplify_gen_subreg(), size_binop_loc(), size_int, sizetype, store_bit_field(), store_by_pieces(), store_expr(), STORE_MAX_PIECES, string_cst_read_str(), SUBREG_CHECK_PROMOTED_SIGN, subreg_promoted_mode(), SUBREG_PROMOTED_SIGN, SUBREG_PROMOTED_VAR_P, SUBREG_REG, subreg_unpromoted_mode(), expand_operand::target, targetm, TREE_CODE, TREE_OPERAND, TREE_STRING_LENGTH, TREE_STRING_POINTER, TREE_TYPE, lang_hooks_for_types::type_for_mode, TYPE_MODE, TYPE_PRECISION, TYPE_UNSIGNED, lang_hooks::types, UINTVAL, profile_probability::uninitialized(), and VOID_TYPE_P.

Referenced by expand_assignment(), expand_expr_real_1(), expand_expr_real_2(), initialize_argument_information(), insert_value_copy_on_edge(), store_constructor(), store_expr(), and store_field().

◆ string_constant()

tree string_constant ( tree arg,
tree * ptr_offset,
tree * mem_size,
tree * decl )
extern
Return STRING_CST and set offset, size and decl, if the first
argument corresponds to a string constant.   
Return STRING_CST if an ARG corresponds to a string constant or zero
if it doesn't.  If we return nonzero, set *PTR_OFFSET to the (possibly
non-constant) offset in bytes within the string that ARG is accessing.
If MEM_SIZE is non-zero the storage size of the memory is returned.
If DECL is non-zero the constant declaration is returned if available.   

References constant_byte_string().

Referenced by c_strlen(), constant_byte_string(), fold_read_from_constant_string(), getbyterep(), gimple_fold_builtin_memory_op(), and simplify_builtin_call().

◆ try_casesi()

bool try_casesi ( tree index_type,
tree index_expr,
tree minval,
tree range,
rtx table_label,
rtx default_label,
rtx fallback_label,
profile_probability default_probability )
extern
Two different ways of generating switch statements.   
Attempt to generate a casesi instruction.  Returns true if successful,
false otherwise (i.e. if there is no casesi instruction).

DEFAULT_PROBABILITY is the probability of jumping to the default
label.   

References build2(), convert_to_mode(), create_convert_operand_from_type(), create_fixed_operand(), create_input_operand(), do_pending_stack_adjust(), emit_cmp_and_jump_insns(), expand_jump_insn(), expand_normal(), fold_convert, GET_MODE_BITSIZE(), integer_zero_node, NULL_RTX, SCALAR_INT_TYPE_MODE, targetm, TREE_TYPE, lang_hooks_for_types::type_for_mode, and lang_hooks::types.

Referenced by emit_case_dispatch_table().

◆ try_store_by_multiple_pieces()

bool try_store_by_multiple_pieces ( rtx to,
rtx len,
unsigned int ctz_len,
unsigned HOST_WIDE_INT min_len,
unsigned HOST_WIDE_INT max_len,
rtx val,
char valc,
unsigned int align )
extern
If can_store_by_pieces passes for worst-case values near MAX_LEN, call
store_by_pieces within conditionals so as to handle variable LEN efficiently,
storing VAL, if non-NULL_RTX, or valc instead.   
Try to store VAL (or, if NULL_RTX, VALC) in LEN bytes starting at TO.
Return TRUE if successful, FALSE otherwise.  TO is assumed to be
aligned at an ALIGN-bits boundary.  LEN must be a multiple of
1<<CTZ_LEN between MIN_LEN and MAX_LEN.

The strategy is to issue one store_by_pieces for each power of two,
from most to least significant, guarded by a test on whether there
are at least that many bytes left to copy in LEN.

??? Should we skip some powers of two in favor of loops?  Maybe start
at the max of TO/LEN/word alignment, at least when optimizing for
size, instead of ensuring O(log len) dynamic compares?   

References builtin_memset_gen_str(), builtin_memset_read_str(), can_store_by_multiple_pieces(), can_store_by_pieces(), change_address(), clear_mem_offset(), convert_to_mode(), copy_addr_to_reg(), copy_to_mode_reg(), emit_cmp_and_jump_insns(), emit_label(), emit_move_insn(), profile_probability::even(), floor_log2(), force_operand(), force_reg(), gcc_checking_assert, GEN_INT, gen_int_mode(), gen_label_rtx(), GET_MODE, HOST_WIDE_INT_1U, i, ILSOP_MEMSET, profile_probability::likely(), MAX, NULL, NULL_RTX, plus_constant(), ptr_mode, replace_equiv_address(), RETURN_BEGIN, RETURN_END, set_mem_align(), store_by_pieces(), TYPE_MODE, unsigned_char_type_node, and XEXP.

Referenced by clear_storage_hints(), and expand_builtin_memset_args().

◆ try_tablejump()

bool try_tablejump ( tree index_type,
tree index_expr,
tree minval,
tree range,
rtx table_label,
rtx default_label,
profile_probability default_probability )
extern

◆ use_group_regs()

void use_group_regs ( rtx * call_fusage,
rtx regs )
extern
Mark a PARALLEL as holding a parameter for the next CALL_INSN.   
Add USE expressions to *CALL_FUSAGE for each REG contained in the
PARALLEL REGS.  This is for calls that pass values in multiple
non-contiguous locations.  The Irix 6 ABI has examples of this.   

References i, REG_P, use_reg(), XEXP, XVECEXP, and XVECLEN.

Referenced by emit_library_call_value_1(), and load_register_parameters().

◆ use_reg()

void use_reg ( rtx * fusage,
rtx reg )
inline
Mark REG as holding a parameter for the next CALL_INSN.   

References use_reg_mode().

Referenced by emit_library_call_value_1(), expand_builtin_apply(), expand_call(), forward_propagate_subreg(), prepare_call_address(), use_group_regs(), and use_regs().

◆ use_reg_mode()

void use_reg_mode ( rtx * call_fusage,
rtx reg,
machine_mode mode )
extern
Mark REG as holding a parameter for the next CALL_INSN.
Mode is TYPE_MODE of the non-promoted parameter, or VOIDmode.   
Add a USE expression for REG to the (possibly empty) list pointed
to by CALL_FUSAGE.  REG must denote a hard register.   

References gcc_assert, gen_rtx_EXPR_LIST(), HARD_REGISTER_P, expand_operand::mode, and REG_P.

Referenced by load_register_parameters(), and use_reg().

◆ use_regs()

void use_regs ( rtx * call_fusage,
int regno,
int nregs )
extern
Mark NREGS consecutive regs, starting at REGNO, as holding parameters
for the next CALL_INSN.   
Add USE expressions to *CALL_FUSAGE for each of NREGS consecutive regs,
starting at REGNO.  All of these registers must be hard registers.   

References gcc_assert, i, regno_reg_rtx, and use_reg().

Referenced by emit_library_call_value_1(), and load_register_parameters().

◆ write_complex_part()

void write_complex_part ( rtx cplx,
rtx val,
bool imag_p,
bool undefined_p )
extern