#include "insn-codes.h"

Include dependency graph for expmed.h:

This graph shows which files directly or indirectly include this file:

Data Structures
struct	mult_cost

struct	algorithm

struct	alg_hash_entry

struct	expmed_op_cheap

struct	expmed_op_costs

struct	target_expmed

Macros
#define	MULT_COST_LESS(X, Y)

#define	CHEAPER_MULT_COST(X, Y)

#define	NUM_ALG_HASH_ENTRIES 307

#define	NUM_MODE_IP_INT (NUM_MODE_INT + NUM_MODE_PARTIAL_INT)

#define	NUM_MODE_IPV_INT (NUM_MODE_IP_INT + NUM_MODE_VECTOR_INT)

#define	this_target_expmed (&default_target_expmed)

Enumerations
enum	alg_code { alg_unknown , alg_zero , alg_m , alg_shift , alg_add_t_m2 , alg_sub_t_m2 , alg_add_factor , alg_sub_factor , alg_add_t2_m , alg_sub_t2_m , alg_impossible }

enum	mult_variant { basic_variant , negate_variant , add_variant }

Functions
bool	choose_mult_variant (machine_mode, HOST_WIDE_INT, struct algorithm , enum mult_variant , int)

struct alg_hash_entry *	alg_hash_entry_ptr (int idx)

bool	alg_hash_used_p (void)

void	set_alg_hash_used_p (bool usedp)

int	expmed_mode_index (machine_mode mode)

bool *	expmed_op_cheap_ptr (struct expmed_op_cheap *eoc, bool speed, machine_mode mode)

int *	expmed_op_cost_ptr (struct expmed_op_costs *costs, bool speed, machine_mode mode)

bool *	sdiv_pow2_cheap_ptr (bool speed, machine_mode mode)

void	set_sdiv_pow2_cheap (bool speed, machine_mode mode, bool cheap_p)

bool	sdiv_pow2_cheap (bool speed, machine_mode mode)

bool *	smod_pow2_cheap_ptr (bool speed, machine_mode mode)

void	set_smod_pow2_cheap (bool speed, machine_mode mode, bool cheap)

bool	smod_pow2_cheap (bool speed, machine_mode mode)

int *	zero_cost_ptr (bool speed)

void	set_zero_cost (bool speed, int cost)

int	zero_cost (bool speed)

int *	add_cost_ptr (bool speed, machine_mode mode)

void	set_add_cost (bool speed, machine_mode mode, int cost)

int	add_cost (bool speed, machine_mode mode)

int *	neg_cost_ptr (bool speed, machine_mode mode)

void	set_neg_cost (bool speed, machine_mode mode, int cost)

int	neg_cost (bool speed, machine_mode mode)

int *	shift_cost_ptr (bool speed, machine_mode mode, int bits)

void	set_shift_cost (bool speed, machine_mode mode, int bits, int cost)

int	shift_cost (bool speed, machine_mode mode, int bits)

int *	shiftadd_cost_ptr (bool speed, machine_mode mode, int bits)

void	set_shiftadd_cost (bool speed, machine_mode mode, int bits, int cost)

int	shiftadd_cost (bool speed, machine_mode mode, int bits)

int *	shiftsub0_cost_ptr (bool speed, machine_mode mode, int bits)

void	set_shiftsub0_cost (bool speed, machine_mode mode, int bits, int cost)

int	shiftsub0_cost (bool speed, machine_mode mode, int bits)

int *	shiftsub1_cost_ptr (bool speed, machine_mode mode, int bits)

void	set_shiftsub1_cost (bool speed, machine_mode mode, int bits, int cost)

int	shiftsub1_cost (bool speed, machine_mode mode, int bits)

int *	mul_cost_ptr (bool speed, machine_mode mode)

void	set_mul_cost (bool speed, machine_mode mode, int cost)

int	mul_cost (bool speed, machine_mode mode)

int *	sdiv_cost_ptr (bool speed, machine_mode mode)

void	set_sdiv_cost (bool speed, machine_mode mode, int cost)

int	sdiv_cost (bool speed, machine_mode mode)

int *	udiv_cost_ptr (bool speed, machine_mode mode)

void	set_udiv_cost (bool speed, machine_mode mode, int cost)

int	udiv_cost (bool speed, machine_mode mode)

int *	mul_widen_cost_ptr (bool speed, machine_mode mode)

void	set_mul_widen_cost (bool speed, machine_mode mode, int cost)

int	mul_widen_cost (bool speed, machine_mode mode)

int *	mul_highpart_cost_ptr (bool speed, machine_mode mode)

void	set_mul_highpart_cost (bool speed, machine_mode mode, int cost)

int	mul_highpart_cost (bool speed, machine_mode mode)

int *	convert_cost_ptr (machine_mode to_mode, machine_mode from_mode, bool speed)

void	set_convert_cost (machine_mode to_mode, machine_mode from_mode, bool speed, int cost)

int	convert_cost (machine_mode to_mode, machine_mode from_mode, bool speed)

int	mult_by_coeff_cost (HOST_WIDE_INT, machine_mode, bool)

rtx	emit_cstore (rtx target, enum insn_code icode, enum rtx_code code, machine_mode mode, machine_mode compare_mode, int unsignedp, rtx x, rtx y, int normalizep, machine_mode target_mode)

rtx	negate_rtx (machine_mode, rtx)

rtx	flip_storage_order (machine_mode, rtx)

rtx	expand_and (machine_mode, rtx, rtx, rtx)

rtx	emit_store_flag (rtx, enum rtx_code, rtx, rtx, machine_mode, int, int)

rtx	emit_store_flag_force (rtx, enum rtx_code, rtx, rtx, machine_mode, int, int)

void	canonicalize_comparison (machine_mode, enum rtx_code , rtx )

unsigned HOST_WIDE_INT	choose_multiplier (unsigned HOST_WIDE_INT, int, int, unsigned HOST_WIDE_INT , int )

void	store_bit_field (rtx, poly_uint64, poly_uint64, poly_uint64, poly_uint64, machine_mode, rtx, bool, bool)

rtx	extract_bit_field (rtx, poly_uint64, poly_uint64, int, rtx, machine_mode, machine_mode, bool, rtx *)

rtx	extract_low_bits (machine_mode, machine_mode, rtx)

rtx	expand_mult (machine_mode, rtx, rtx, rtx, int, bool=false)

rtx	expand_mult_highpart_adjust (scalar_int_mode, rtx, rtx, rtx, rtx, int)

rtx	expmed_mult_highpart_optab (scalar_int_mode, rtx, rtx, rtx, int, int)

Variables
struct target_expmed	default_target_expmed

Macro Definition Documentation

◆ CHEAPER_MULT_COST

#define CHEAPER_MULT_COST	(		X,
			Y )

Value:

                                 ((X)->cost < (Y)->cost         \
                                 || ((X)->cost == (Y)->cost     \
                                     && (X)->latency < (Y)->latency))

This macro is used to compare two pointers to mult_costs against
each other.  The macro returns true if X is cheaper than Y.
Currently, the cheaper of two mult_costs is the one with the
lower "cost".  If "cost"s are tied, the lower latency is cheaper.

Referenced by choose_mult_variant(), and synth_mult().

◆ MULT_COST_LESS

#define MULT_COST_LESS	(		X,
			Y )

Value:

((X)->cost < (Y) \

|| ((X)->cost == (Y) && (X)->latency < (Y)))

This macro is used to compare a pointer to a mult_cost against an
single integer "rtx_cost" value.  This is equivalent to the macro
CHEAPER_MULT_COST(X,Z) where Z = {Y,Y}.

Referenced by choose_mult_variant(), and synth_mult().

◆ NUM_ALG_HASH_ENTRIES

#define NUM_ALG_HASH_ENTRIES 307

The number of cache/hash entries.

Referenced by init_expmed(), and synth_mult().

◆ NUM_MODE_IP_INT

#define NUM_MODE_IP_INT (NUM_MODE_INT + NUM_MODE_PARTIAL_INT)

Referenced by convert_cost_ptr(), and expmed_mode_index().

◆ NUM_MODE_IPV_INT

#define NUM_MODE_IPV_INT (NUM_MODE_IP_INT + NUM_MODE_VECTOR_INT)

◆ this_target_expmed

#define this_target_expmed (&default_target_expmed)

Referenced by add_cost_ptr(), alg_hash_entry_ptr(), alg_hash_used_p(), convert_cost_ptr(), mul_cost_ptr(), mul_highpart_cost_ptr(), mul_widen_cost_ptr(), neg_cost_ptr(), sdiv_cost_ptr(), sdiv_pow2_cheap_ptr(), set_alg_hash_used_p(), shift_cost_ptr(), shiftadd_cost_ptr(), shiftsub0_cost_ptr(), shiftsub1_cost_ptr(), smod_pow2_cheap_ptr(), udiv_cost_ptr(), and zero_cost_ptr().

Enumeration Type Documentation

◆ alg_code

enum alg_code

Target-dependent costs for expmed.cc.
   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/>.

Enumerator
alg_unknown
alg_zero
alg_m
alg_shift
alg_add_t_m2
alg_sub_t_m2
alg_add_factor
alg_sub_factor
alg_add_t2_m
alg_sub_t2_m
alg_impossible

◆ mult_variant

enum mult_variant

Indicates the type of fixup needed after a constant multiplication.
BASIC_VARIANT means no fixup is needed, NEGATE_VARIANT means that
the result should be negated, and ADD_VARIANT means that the
multiplicand should be added to the result.

Enumerator
basic_variant
negate_variant
add_variant

Function Documentation

◆ add_cost()

int add_cost	(	bool	speed,
		machine_mode	mode )

inline

Return the cost of computing an add in MODE when optimizing for SPEED.

References add_cost_ptr(), alg_hash_entry::mode, and alg_hash_entry::speed.

Referenced by add_dependency(), analyze_increments(), assign_hard_reg(), vect_optimize_slp_pass::backward_pass(), choose_mult_variant(), determine_iv_cost(), expand_divmod(), expand_expr_real_2(), expand_shift_1(), expmed_mult_highpart(), expmed_mult_highpart_optab(), find_costs_and_classes(), force_expr_to_var_cost(), vect_optimize_slp_pass::forward_pass(), get_address_cost(), get_computation_cost(), get_shiftadd_cost(), improve_allocation(), init_expmed_one_mode(), phi_incr_cost_1(), record_address_regs(), replace_uncond_cands_and_profitable_phis(), scan_one_insn(), stmt_cost(), synth_mult(), and vect_optimize_slp_pass::total_in_cost().

◆ add_cost_ptr()

int * add_cost_ptr	(	bool	speed,
		machine_mode	mode )

inline

Subroutine of {set_,}add_cost.  Not to be used otherwise.

References expmed_op_cost_ptr(), alg_hash_entry::mode, alg_hash_entry::speed, and this_target_expmed.

Referenced by add_cost(), and set_add_cost().

◆ alg_hash_entry_ptr()

struct alg_hash_entry * alg_hash_entry_ptr ( int idx )

inline

Return a pointer to the alg_hash_entry at IDX.

References this_target_expmed.

Referenced by init_expmed(), and synth_mult().

◆ alg_hash_used_p()

bool alg_hash_used_p ( void )

inline

Return true if the x_alg_hash field might have been used.

References this_target_expmed.

Referenced by init_expmed().

◆ canonicalize_comparison()

void canonicalize_comparison	(	machine_mode	mode,
		enum rtx_code *	code,
		rtx *	imm )

extern

Choose the more appropiate immediate in scalar integer comparisons.  The
purpose of this is to end up with an immediate which can be loaded into a
register in fewer moves, if possible.

For each integer comparison there exists an equivalent choice:
  i)   a >  b or a >= b + 1
  ii)  a <= b or a <  b + 1
  iii) a >= b or a >  b - 1
  iv)  a <  b or a <= b - 1

MODE is the mode of the first operand.
CODE points to the comparison code.
IMM points to the rtx containing the immediate.  *IMM must satisfy
CONST_SCALAR_INT_P on entry and continues to satisfy CONST_SCALAR_INT_P
on exit.

References wi::add(), can_create_pseudo_p, equivalent_cmp_code(), gen_move_insn(), gen_rtx_REG(), ggc_alloc(), immed_wide_int_const(), insn_cost(), LAST_VIRTUAL_REGISTER, expand_operand::mode, wi::OVF_NONE, SCALAR_INT_MODE_P, SIGNED, wi::sub(), UNSIGNED, and unsigned_condition_p().

Referenced by emit_store_flag_1(), and prepare_cmp_insn().

◆ choose_mult_variant()

bool choose_mult_variant	(	machine_mode	mode,
		HOST_WIDE_INT	val,
		struct algorithm *	alg,
		enum mult_variant *	variant,
		int	mult_cost )

Find the cheapest way of multiplying a value of mode MODE by VAL.
Try three variations:

    - a shift/add sequence based on VAL itself
    - a shift/add sequence based on -VAL, followed by a negation
    - a shift/add sequence based on VAL - 1, followed by an addition.

Return true if the cheapest of these cost less than MULT_COST,
describing the algorithm in *ALG and final fixup in *VARIANT.

References add_cost(), add_variant, basic_variant, CHEAPER_MULT_COST, mult_cost::cost, algorithm::cost, GET_MODE_UNIT_BITSIZE, GET_MODE_UNIT_PRECISION, ggc_alloc(), HOST_BITS_PER_INT, HOST_BITS_PER_WIDE_INT, HOST_WIDE_INT_1U, HOST_WIDE_INT_MIN, mult_cost::latency, MULT_COST_LESS, neg_cost(), negate_variant, optimize_insn_for_speed_p(), and synth_mult().

Referenced by expand_expr_real_2(), expand_mult(), expand_widening_mult(), expmed_mult_highpart(), mult_by_coeff_cost(), and vect_synth_mult_by_constant().

◆ choose_multiplier()

unsigned HOST_WIDE_INT choose_multiplier	(	unsigned HOST_WIDE_INT	d,
		int	n,
		int	precision,
		unsigned HOST_WIDE_INT *	multiplier_ptr,
		int *	post_shift_ptr )

extern

Choose a minimal N + 1 bit approximation to 2**K / D that can be used to
replace division by D, put the least significant N bits of the result in
*MULTIPLIER_PTR, the value K - N in *POST_SHIFT_PTR, and return the most
significant bit.

Choose a minimal N + 1 bit approximation to 2**K / D that can be used to
replace division by D, put the least significant N bits of the result in
*MULTIPLIER_PTR, the value K - N in *POST_SHIFT_PTR, and return the most
significant bit.

The width of operations is N (should be <= HOST_BITS_PER_WIDE_INT), the
needed precision is PRECISION (should be <= N).

PRECISION should be as small as possible so this function can choose the
multiplier more freely.  If PRECISION is <= N - 1, the most significant
bit returned by the function will be zero.

Using this function, x / D is equal to (x*m) / 2**N >> (*POST_SHIFT_PTR),
where m is the full N + 1 bit multiplier.

References ceil_log2(), wi::extract_uhwi(), gcc_assert, ggc_alloc(), HOST_BITS_PER_DOUBLE_INT, HOST_BITS_PER_WIDE_INT, HOST_WIDE_INT_1U, wi::set_bit_in_zero(), wi::udiv_trunc(), and wi::uhwi().

Referenced by expand_divmod(), expand_vector_divmod(), and vect_recog_divmod_pattern().

◆ convert_cost()

int convert_cost	(	machine_mode	to_mode,
		machine_mode	from_mode,
		bool	speed )

inline

Return the cost for converting from FROM_MODE to TO_MODE when optimizing
for SPEED.

References convert_cost_ptr(), ggc_alloc(), and alg_hash_entry::speed.

Referenced by force_expr_to_var_cost(), get_computation_cost(), and stmt_cost().

◆ convert_cost_ptr()

int * convert_cost_ptr	(	machine_mode	to_mode,
		machine_mode	from_mode,
		bool	speed )

inline

Subroutine of {set_,}convert_cost.  Not to be used otherwise.

References expmed_mode_index(), gcc_assert, ggc_alloc(), IN_RANGE, NUM_MODE_IP_INT, alg_hash_entry::speed, and this_target_expmed.

Referenced by convert_cost(), and set_convert_cost().

◆ emit_cstore()

rtx emit_cstore	(	rtx	target,
		enum insn_code	icode,
		enum rtx_code	code,
		machine_mode	mode,
		machine_mode	compare_mode,
		int	unsignedp,
		rtx	x,
		rtx	y,
		int	normalizep,
		machine_mode	target_mode )

extern

Helper function for emit_store_flag.

References const1_rtx, convert_move(), create_fixed_operand(), create_output_operand(), delete_insns_since(), expand_and(), expand_shift(), expand_unop(), gcc_assert, gen_reg_rtx(), get_last_insn(), GET_MODE_BITSIZE(), GET_MODE_PRECISION(), ggc_alloc(), last, maybe_expand_insn(), expand_operand::mode, NULL_RTX, prepare_operand(), STORE_FLAG_VALUE, expand_operand::target, targetm, val_signbit_known_set_p(), expand_operand::value, and y.

Referenced by emit_store_flag_1(), and expand_ccmp_expr().

◆ emit_store_flag()

rtx emit_store_flag	(	rtx	target,
		enum rtx_code	code,
		rtx	op0,
		rtx	op1,
		machine_mode	mode,
		int	unsignedp,
		int	normalizep )

extern

Emit a store-flag operation.

Emit a store-flags instruction for comparison CODE on OP0 and OP1
and storing in TARGET.  Normally return TARGET.
Return 0 if that cannot be done.

MODE is the mode to use for OP0 and OP1 should they be CONST_INTs.  If
it is VOIDmode, they cannot both be CONST_INT.

UNSIGNEDP is for the case where we have to widen the operands
to perform the operation.  It says to use zero-extension.

NORMALIZEP is 1 if we should convert the result to be either zero
or one.  Normalize is -1 if we should convert the result to be
either zero or -1.  If NORMALIZEP is zero, the result will be left
"raw" out of the scc insn.

References can_compare_p(), ccp_store_flag, const0_rtx, CONSTANT_P, delete_insns_since(), emit_conditional_move(), emit_store_flag_1(), emit_store_flag_int(), expand_binop(), gcc_assert, GEN_INT, gen_int_mode(), get_last_insn(), GET_MODE, GET_MODE_CLASS, ggc_alloc(), HONOR_NANS(), HONOR_SNANS(), INTVAL, is_int_mode(), last, expand_operand::mode, NULL_RTX, OPTAB_WIDEN, optimize_insn_for_speed_p(), reverse_condition_maybe_unordered(), rtx_cost(), split_comparison(), STORE_FLAG_VALUE, expand_operand::target, and val_signbit_p().

Referenced by emit_store_flag_1(), emit_store_flag_force(), emit_store_flag_int(), expand_divmod(), expand_POPCOUNT(), expand_sdiv_pow2(), expand_smod_pow2(), noce_emit_store_flag(), and noce_try_sign_mask().

◆ emit_store_flag_force()

rtx emit_store_flag_force	(	rtx	target,
		enum rtx_code	code,
		rtx	op0,
		rtx	op1,
		machine_mode	mode,
		int	unsignedp,
		int	normalizep )

extern

Like emit_store_flag, but always succeeds.

References can_compare_p(), ccp_jump, const0_rtx, const1_rtx, do_compare_rtx_and_jump(), emit_label(), emit_move_insn(), emit_store_flag(), FLOAT_MODE_P, GEN_INT, gen_label_rtx(), gen_reg_rtx(), GET_MODE, GET_MODE_CLASS, ggc_alloc(), HONOR_NANS(), HONOR_SNANS(), expand_operand::mode, NULL, NULL_RTX, reg_mentioned_p(), REG_P, reverse_condition(), reverse_condition_maybe_unordered(), swap_commutative_operands_p(), swap_condition(), expand_operand::target, profile_probability::uninitialized(), and word_mode.

Referenced by convert_mode_scalar(), do_store_flag(), expand_atomic_compare_and_swap(), expand_atomic_test_and_set(), expand_binop(), expand_builtin_issignaling(), expand_divmod(), and expand_ifn_atomic_op_fetch_cmp_0().

◆ expand_and()

rtx expand_and	(	machine_mode	mode,
		rtx	op0,
		rtx	op1,
		rtx	target )

extern

Expand a logical AND operation.

Compute the logical-and of OP0 and OP1, storing it in TARGET
and returning TARGET.

If TARGET is 0, a pseudo-register or constant is returned.

References emit_move_insn(), expand_binop(), GET_MODE, ggc_alloc(), OPTAB_LIB_WIDEN, and simplify_binary_operation().

Referenced by emit_cstore(), expand_builtin_extract_return_addr(), expand_expr_real_2(), expand_mult_highpart_adjust(), optimize_bitfield_assignment_op(), and reduce_to_bit_field_precision().

◆ expand_mult()

rtx expand_mult	(	machine_mode	mode,
		rtx	op0,
		rtx	op1,
		rtx	target,
		int	unsignedp,
		bool	no_libcall )

extern

Perform a multiplication and return an rtx for the result.
MODE is mode of value; OP0 and OP1 are what to multiply (rtx's);
TARGET is a suggestion for where to store the result (an rtx).

We check specially for a constant integer as OP1.
If you want this check for OP0 as well, then before calling
you should swap the two operands if OP0 would be constant.

References choose_mult_variant(), CONST0_RTX, CONST1_RTX, CONST_DOUBLE_AS_FLOAT_P, CONST_DOUBLE_AS_INT_P, CONST_DOUBLE_REAL_VALUE, CONST_INT_P, CONST_WIDE_INT_P, CONSTANT_P, CONSTM1_RTX, dconst2, wi::exact_log2(), EXACT_POWER_OF_2_OR_ZERO_P, expand_binop(), expand_mult_const(), expand_shift(), expand_unop(), floor_log2(), force_reg(), gcc_assert, gen_raw_REG(), GET_MODE, GET_MODE_CLASS, GET_MODE_UNIT_BITSIZE, ggc_alloc(), HOST_BITS_PER_WIDE_INT, INTEGRAL_MODE_P, INTVAL, LAST_VIRTUAL_REGISTER, neg_cost(), NULL_RTX, optab_handler(), OPTAB_LIB_WIDEN, OPTAB_WIDEN, optimize_insn_for_speed_p(), real_equal(), SCALAR_INT_MODE_P, set_src_cost(), shift, and unwrap_const_vec_duplicate().

Referenced by align_dynamic_address(), builtin_memset_gen_str(), can_widen_mult_without_libcall(), expand_divmod(), expand_expr_real_2(), force_operand(), index_part_to_reg(), and round_push().

◆ expand_mult_highpart_adjust()

rtx expand_mult_highpart_adjust	(	scalar_int_mode	mode,
		rtx	adj_operand,
		rtx	op0,
		rtx	op1,
		rtx	target,
		int	unsignedp )

extern

Emit code to adjust ADJ_OPERAND after multiplication of wrong signedness
flavor of OP0 and OP1.  ADJ_OPERAND is already the high half of the
product OP0 x OP1.  If UNSIGNEDP is nonzero, adjust the signed product
to become unsigned, if UNSIGNEDP is zero, adjust the unsigned product to
become signed.

The result is put in TARGET if that is convenient.

MODE is the mode of operation.

References expand_and(), expand_shift(), force_operand(), GET_MODE_BITSIZE(), ggc_alloc(), and NULL_RTX.

Referenced by expand_expr_real_2(), and expmed_mult_highpart_optab().

◆ expmed_mode_index()

int expmed_mode_index ( machine_mode mode )

inline

Compute an index into the cost arrays by mode class.

References gcc_unreachable, GET_MODE_CLASS, ggc_alloc(), alg_hash_entry::mode, and NUM_MODE_IP_INT.

Referenced by convert_cost_ptr(), expmed_op_cheap_ptr(), expmed_op_cost_ptr(), shift_cost_ptr(), shiftadd_cost_ptr(), shiftsub0_cost_ptr(), and shiftsub1_cost_ptr().

◆ expmed_mult_highpart_optab()

rtx expmed_mult_highpart_optab	(	scalar_int_mode	mode,
		rtx	op0,
		rtx	op1,
		rtx	target,
		int	unsignedp,
		int	max_cost )

extern

Like expmed_mult_highpart, but only consider using multiplication optab.

References add_cost(), BITS_PER_WORD, convert_modes(), convert_optab_handler(), emit_insn(), end_sequence(), expand_binop(), expand_mult_highpart_adjust(), extract_high_half(), get_insns(), GET_MODE_BITSIZE(), GET_MODE_WIDER_MODE(), ggc_alloc(), insns, mul_cost(), mul_highpart_cost(), mul_widen_cost(), NULL_RTX, OPTAB_DIRECT, optab_handler(), OPTAB_WIDEN, optimize_insn_for_speed_p(), shift_cost(), and start_sequence().

Referenced by expand_mult_highpart(), and expmed_mult_highpart().

◆ expmed_op_cheap_ptr()

bool * expmed_op_cheap_ptr	(	struct expmed_op_cheap *	eoc,
		bool	speed,
		machine_mode	mode )

inline

Return a pointer to a boolean contained in EOC indicating whether
a particular operation performed in MODE is cheap when optimizing
for SPEED.

References expmed_mode_index(), ggc_alloc(), alg_hash_entry::mode, and alg_hash_entry::speed.

Referenced by sdiv_pow2_cheap_ptr(), and smod_pow2_cheap_ptr().

◆ expmed_op_cost_ptr()

int * expmed_op_cost_ptr	(	struct expmed_op_costs *	costs,
		bool	speed,
		machine_mode	mode )

inline

Return a pointer to a cost contained in COSTS when a particular
operation is performed in MODE when optimizing for SPEED.

References costs::cost, expmed_mode_index(), alg_hash_entry::mode, and alg_hash_entry::speed.

Referenced by add_cost_ptr(), mul_cost_ptr(), neg_cost_ptr(), sdiv_cost_ptr(), and udiv_cost_ptr().

◆ extract_bit_field()

rtx extract_bit_field	(	rtx	str_rtx,
		poly_uint64	bitsize,
		poly_uint64	bitnum,
		int	unsignedp,
		rtx	target,
		machine_mode	mode,
		machine_mode	tmode,
		bool	reverse,
		rtx *	alt_rtl )

extern

Generate code to extract a byte-field from STR_RTX
containing BITSIZE bits, starting at BITNUM,
and put it in TARGET if possible (if TARGET is nonzero).
Regardless of TARGET, we return the rtx for where the value is placed.

STR_RTX is the structure containing the byte (a REG or MEM).
UNSIGNEDP is nonzero if this is an unsigned bit field.
MODE is the natural mode of the field value once extracted.
TMODE is the mode the caller would like the value to have;
but the value may be returned with type MODE instead.

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

If a TARGET is specified and we can store in it at no extra cost,
we do so, and return TARGET.
Otherwise, we return a REG of mode TMODE or MODE, with TMODE preferred
if they are equally easy.

If the result can be stored at TARGET, and ALT_RTL is non-NULL,
then *ALT_RTL is set to TARGET (before legitimziation).

References adjust_bitfield_address, convert_extracted_bit_field(), copy_to_reg(), extract_bit_field_1(), flip_storage_order(), gcc_assert, GET_MODE, GET_MODE_BITSIZE(), ggc_alloc(), poly_int< N, C >::is_constant(), expand_operand::mode, narrow_bit_field_mem(), strict_volatile_bitfield_p(), and expand_operand::target.

Referenced by assign_parm_setup_reg(), copy_blkmode_from_reg(), copy_blkmode_to_reg(), emit_group_load_1(), expand_expr_real_1(), expand_misaligned_mem_ref(), expand_single_bit_test(), load_register_parameters(), read_complex_part(), store_field(), store_integral_bit_field(), and store_unaligned_arguments_into_pseudos().

◆ extract_low_bits()

rtx extract_low_bits	(	machine_mode	mode,
		machine_mode	src_mode,
		rtx	src )

extern

Try to read the low bits of SRC as an rvalue of mode MODE, preserving
the bit pattern.  SRC_MODE is the mode of SRC; if this is smaller than
MODE, fill the upper bits with zeros.  Fail if the layout of either
mode is unknown (as for CC modes) or if the extraction would involve
unprofitable mode punning.  Return the value on success, otherwise
return null.

This is different from gen_lowpart* in these respects:

  - the returned value must always be considered an rvalue

  - when MODE is wider than SRC_MODE, the extraction involves
    a zero extension

  - when MODE is smaller than SRC_MODE, the extraction involves
    a truncation (and is thus subject to TARGET_TRULY_NOOP_TRUNCATION).

In other words, this routine performs a computation, whereas the
gen_lowpart* routines are conceptually lvalue or rvalue subreg
operations.

References CONSTANT_P, convert_modes(), force_reg(), gen_lowpart, gen_lowpart_common(), gen_rtx_SUBREG(), GET_MODE, GET_MODE_BITSIZE(), GET_MODE_CLASS, ggc_alloc(), int_mode_for_mode(), known_eq, expand_operand::mode, NULL_RTX, simplify_subreg(), subreg_lowpart_offset(), targetm, and validate_subreg().

Referenced by find_shift_sequence(), and get_stored_val().

◆ flip_storage_order()

rtx flip_storage_order	(	machine_mode	mode,
		rtx	x )

extern

Arguments MODE, RTX: return an rtx for the flipping of that value.
May emit insns.

Return an rtx representing value of X with reverse storage order.
MODE is the intended mode of the result,
useful if X is a CONST_INT.

References check_reverse_float_storage_order_support(), check_reverse_storage_order_support(), COMPLEX_MODE_P, expand_unop(), flip_storage_order(), FLOAT_MODE_P, gen_lowpart, GET_MODE_INNER, GET_MODE_NAME, GET_MODE_PRECISION(), ggc_alloc(), int_mode_for_size(), alg_hash_entry::mode, NULL_RTX, read_complex_part(), reverse_float_storage_order_supported, reverse_storage_order_supported, simplify_unary_operation(), sorry(), targetm, and UNLIKELY.

Referenced by assemble_real(), expand_assignment(), expand_expr_real_1(), extract_bit_field(), extract_bit_field_1(), extract_fixed_bit_field_1(), extract_integral_bit_field(), flip_storage_order(), optimize_bitfield_assignment_op(), output_constant(), store_bit_field(), store_bit_field_1(), store_expr(), store_field(), and store_fixed_bit_field_1().

◆ mul_cost()

int mul_cost	(	bool	speed,
		machine_mode	mode )

inline

Return the cost of doing a multiplication in MODE when optimizing
for SPEED.

References alg_hash_entry::mode, mul_cost_ptr(), and alg_hash_entry::speed.

Referenced by analyze_increments(), expand_divmod(), expand_expr_real_2(), expmed_mult_highpart_optab(), and stmt_cost().

◆ mul_cost_ptr()

int * mul_cost_ptr	(	bool	speed,
		machine_mode	mode )

inline

Subroutine of {set_,}mul_cost.  Not to be used otherwise.

References expmed_op_cost_ptr(), alg_hash_entry::mode, alg_hash_entry::speed, and this_target_expmed.

Referenced by mul_cost(), and set_mul_cost().

◆ mul_highpart_cost()

int mul_highpart_cost	(	bool	speed,
		machine_mode	mode )

inline

Return the cost for computing the high part of a multiplication in MODE
when optimizing for SPEED.

References alg_hash_entry::mode, mul_highpart_cost_ptr(), and alg_hash_entry::speed.

Referenced by expmed_mult_highpart_optab().

◆ mul_highpart_cost_ptr()

int * mul_highpart_cost_ptr	(	bool	speed,
		machine_mode	mode )

inline

Subroutine of {set_,}mul_highpart_cost.  Not to be used otherwise.

References gcc_assert, GET_MODE_CLASS, ggc_alloc(), alg_hash_entry::mode, alg_hash_entry::speed, and this_target_expmed.

Referenced by mul_highpart_cost(), and set_mul_highpart_cost().

◆ mul_widen_cost()

int mul_widen_cost	(	bool	speed,
		machine_mode	mode )

inline

Return the cost for computing a widening multiplication in MODE when
optimizing for SPEED.

References alg_hash_entry::mode, mul_widen_cost_ptr(), and alg_hash_entry::speed.

Referenced by expand_widening_mult(), and expmed_mult_highpart_optab().

◆ mul_widen_cost_ptr()

int * mul_widen_cost_ptr	(	bool	speed,
		machine_mode	mode )

inline

Subroutine of {set_,}mul_widen_cost.  Not to be used otherwise.

References gcc_assert, GET_MODE_CLASS, ggc_alloc(), alg_hash_entry::mode, alg_hash_entry::speed, and this_target_expmed.

Referenced by mul_widen_cost(), and set_mul_widen_cost().

◆ mult_by_coeff_cost()

int mult_by_coeff_cost	(	HOST_WIDE_INT	coeff,
		machine_mode	mode,
		bool	speed )

extern

Return a cost estimate for multiplying a register by the given
COEFFicient in the given MODE and SPEED.

References choose_mult_variant(), mult_cost::cost, algorithm::cost, gen_raw_REG(), ggc_alloc(), LAST_VIRTUAL_REGISTER, and set_src_cost().

Referenced by analyze_increments(), force_expr_to_var_cost(), get_address_cost(), get_computation_cost(), most_expensive_mult_to_index(), and stmt_cost().

◆ neg_cost()

int neg_cost	(	bool	speed,
		machine_mode	mode )

inline

Return the cost of computing a negation in MODE when optimizing for
SPEED.

References alg_hash_entry::mode, neg_cost_ptr(), and alg_hash_entry::speed.

Referenced by choose_mult_variant(), expand_expr_real_2(), expand_mult(), and stmt_cost().

◆ neg_cost_ptr()

int * neg_cost_ptr	(	bool	speed,
		machine_mode	mode )

inline

Subroutine of {set_,}neg_cost.  Not to be used otherwise.

References expmed_op_cost_ptr(), alg_hash_entry::mode, alg_hash_entry::speed, and this_target_expmed.

Referenced by neg_cost(), and set_neg_cost().

◆ negate_rtx()

rtx negate_rtx	(	machine_mode	mode,
		rtx	x )

extern

Arguments MODE, RTX: return an rtx for the negation of that value.
May emit insns.

Return an rtx representing minus the value of X.
MODE is the intended mode of the result,
useful if X is a CONST_INT.

References expand_unop(), ggc_alloc(), alg_hash_entry::mode, NULL_RTX, and simplify_unary_operation().

Referenced by expand_binop(), expand_builtin_apply(), expand_expr_real_2(), fill_slots_from_thread(), force_operand(), and push_block().

◆ sdiv_cost()

int sdiv_cost	(	bool	speed,
		machine_mode	mode )

inline

Return the cost of doing a signed division in MODE when optimizing
for SPEED.

References alg_hash_entry::mode, sdiv_cost_ptr(), and alg_hash_entry::speed.

Referenced by expand_divmod().

◆ sdiv_cost_ptr()

int * sdiv_cost_ptr	(	bool	speed,
		machine_mode	mode )

inline

Subroutine of {set_,}sdiv_cost.  Not to be used otherwise.

References expmed_op_cost_ptr(), alg_hash_entry::mode, alg_hash_entry::speed, and this_target_expmed.

Referenced by sdiv_cost(), and set_sdiv_cost().

◆ sdiv_pow2_cheap()

bool sdiv_pow2_cheap	(	bool	speed,
		machine_mode	mode )

inline

Return whether a signed division by a power of 2 is cheap in MODE
when optimizing for SPEED.

References alg_hash_entry::mode, sdiv_pow2_cheap_ptr(), and alg_hash_entry::speed.

Referenced by expand_divmod().

◆ sdiv_pow2_cheap_ptr()

bool * sdiv_pow2_cheap_ptr	(	bool	speed,
		machine_mode	mode )

inline

Subroutine of {set_,}sdiv_pow2_cheap.  Not to be used otherwise.

References expmed_op_cheap_ptr(), alg_hash_entry::mode, alg_hash_entry::speed, and this_target_expmed.

Referenced by sdiv_pow2_cheap(), and set_sdiv_pow2_cheap().

◆ set_add_cost()

void set_add_cost	(	bool	speed,
		machine_mode	mode,
		int	cost )

inline

Set the COST of computing an add in MODE when optimizing for SPEED.

References add_cost_ptr(), alg_hash_entry::cost, alg_hash_entry::mode, and alg_hash_entry::speed.

Referenced by init_expmed_one_mode().

◆ set_alg_hash_used_p()

void set_alg_hash_used_p ( bool usedp )

inline

Set whether the x_alg_hash field might have been used.

References ggc_alloc(), and this_target_expmed.

Referenced by init_expmed().

◆ set_convert_cost()

void set_convert_cost	(	machine_mode	to_mode,
		machine_mode	from_mode,
		bool	speed,
		int	cost )

inline

Set the COST for converting from FROM_MODE to TO_MODE when optimizing
for SPEED.

References convert_cost_ptr(), alg_hash_entry::cost, ggc_alloc(), and alg_hash_entry::speed.

Referenced by init_expmed_one_conv().

◆ set_mul_cost()

void set_mul_cost	(	bool	speed,
		machine_mode	mode,
		int	cost )

inline

Set the COST of doing a multiplication in MODE when optimizing for
SPEED.

References alg_hash_entry::cost, alg_hash_entry::mode, mul_cost_ptr(), and alg_hash_entry::speed.

Referenced by init_expmed_one_mode().

◆ set_mul_highpart_cost()

void set_mul_highpart_cost	(	bool	speed,
		machine_mode	mode,
		int	cost )

inline

Set the COST for computing the high part of a multiplication in MODE
when optimizing for SPEED.

References alg_hash_entry::cost, alg_hash_entry::mode, mul_highpart_cost_ptr(), and alg_hash_entry::speed.

Referenced by init_expmed_one_mode().

◆ set_mul_widen_cost()

void set_mul_widen_cost	(	bool	speed,
		machine_mode	mode,
		int	cost )

inline

Set the COST for computing a widening multiplication in MODE when
optimizing for SPEED.

References alg_hash_entry::cost, alg_hash_entry::mode, mul_widen_cost_ptr(), and alg_hash_entry::speed.

Referenced by init_expmed_one_mode().

◆ set_neg_cost()

void set_neg_cost	(	bool	speed,
		machine_mode	mode,
		int	cost )

inline

Set the COST of computing a negation in MODE when optimizing for SPEED.

References alg_hash_entry::cost, alg_hash_entry::mode, neg_cost_ptr(), and alg_hash_entry::speed.

Referenced by init_expmed_one_mode().

◆ set_sdiv_cost()

void set_sdiv_cost	(	bool	speed,
		machine_mode	mode,
		int	cost )

inline

Set the COST of doing a signed division in MODE when optimizing
for SPEED.

References alg_hash_entry::cost, alg_hash_entry::mode, sdiv_cost_ptr(), and alg_hash_entry::speed.

Referenced by init_expmed_one_mode().

◆ set_sdiv_pow2_cheap()

void set_sdiv_pow2_cheap	(	bool	speed,
		machine_mode	mode,
		bool	cheap_p )

inline

Set whether a signed division by a power of 2 is cheap in MODE
when optimizing for SPEED.

References ggc_alloc(), alg_hash_entry::mode, sdiv_pow2_cheap_ptr(), and alg_hash_entry::speed.

Referenced by init_expmed_one_mode().

◆ set_shift_cost()

void set_shift_cost	(	bool	speed,
		machine_mode	mode,
		int	bits,
		int	cost )

inline

Set the COST of doing a shift in MODE by BITS when optimizing for SPEED.

References alg_hash_entry::cost, alg_hash_entry::mode, shift_cost_ptr(), and alg_hash_entry::speed.

Referenced by init_expmed_one_mode().

◆ set_shiftadd_cost()

void set_shiftadd_cost	(	bool	speed,
		machine_mode	mode,
		int	bits,
		int	cost )

inline

Set the COST of doing a shift in MODE by BITS followed by an add when
optimizing for SPEED.

References alg_hash_entry::cost, alg_hash_entry::mode, shiftadd_cost_ptr(), and alg_hash_entry::speed.

Referenced by init_expmed_one_mode().

◆ set_shiftsub0_cost()

void set_shiftsub0_cost	(	bool	speed,
		machine_mode	mode,
		int	bits,
		int	cost )

inline

Set the COST of doing a shift in MODE by BITS and then subtracting a
value when optimizing for SPEED.

References alg_hash_entry::cost, alg_hash_entry::mode, shiftsub0_cost_ptr(), and alg_hash_entry::speed.

Referenced by init_expmed_one_mode().

◆ set_shiftsub1_cost()

void set_shiftsub1_cost	(	bool	speed,
		machine_mode	mode,
		int	bits,
		int	cost )

inline

Set the COST of subtracting a shift in MODE by BITS from a value when
optimizing for SPEED.

References alg_hash_entry::cost, alg_hash_entry::mode, shiftsub1_cost_ptr(), and alg_hash_entry::speed.

Referenced by init_expmed_one_mode().

◆ set_smod_pow2_cheap()

void set_smod_pow2_cheap	(	bool	speed,
		machine_mode	mode,
		bool	cheap )

inline

Set whether a signed modulo by a power of 2 is CHEAP in MODE when
optimizing for SPEED.

References alg_hash_entry::mode, smod_pow2_cheap_ptr(), and alg_hash_entry::speed.

Referenced by init_expmed_one_mode().

◆ set_udiv_cost()

void set_udiv_cost	(	bool	speed,
		machine_mode	mode,
		int	cost )

inline

Set the COST of doing an unsigned division in MODE when optimizing
for SPEED.

References alg_hash_entry::cost, alg_hash_entry::mode, alg_hash_entry::speed, and udiv_cost_ptr().

Referenced by init_expmed_one_mode().

◆ set_zero_cost()

void set_zero_cost	(	bool	speed,
		int	cost )

inline

Set the COST of loading zero when optimizing for SPEED.

References alg_hash_entry::cost, alg_hash_entry::speed, and zero_cost_ptr().

Referenced by init_expmed().

◆ shift_cost()

int shift_cost	(	bool	speed,
		machine_mode	mode,
		int	bits )

inline

Return the cost of doing a shift in MODE by BITS when optimizing for
SPEED.

References alg_hash_entry::mode, shift_cost_ptr(), and alg_hash_entry::speed.

Referenced by expand_divmod(), expand_sdiv_pow2(), expand_shift_1(), expmed_mult_highpart(), expmed_mult_highpart_optab(), get_shiftadd_cost(), and synth_mult().

◆ shift_cost_ptr()

int * shift_cost_ptr	(	bool	speed,
		machine_mode	mode,
		int	bits )

inline

Subroutine of {set_,}shift_cost.  Not to be used otherwise.

References expmed_mode_index(), ggc_alloc(), alg_hash_entry::mode, alg_hash_entry::speed, and this_target_expmed.

Referenced by set_shift_cost(), and shift_cost().

◆ shiftadd_cost()

int shiftadd_cost	(	bool	speed,
		machine_mode	mode,
		int	bits )

inline

Return the cost of doing a shift in MODE by BITS followed by an add
when optimizing for SPEED.

References alg_hash_entry::mode, shiftadd_cost_ptr(), and alg_hash_entry::speed.

Referenced by get_shiftadd_cost(), and synth_mult().

◆ shiftadd_cost_ptr()

int * shiftadd_cost_ptr	(	bool	speed,
		machine_mode	mode,
		int	bits )

inline

Subroutine of {set_,}shiftadd_cost.  Not to be used otherwise.

References expmed_mode_index(), ggc_alloc(), alg_hash_entry::mode, alg_hash_entry::speed, and this_target_expmed.

Referenced by set_shiftadd_cost(), and shiftadd_cost().

◆ shiftsub0_cost()

int shiftsub0_cost	(	bool	speed,
		machine_mode	mode,
		int	bits )

inline

Return the cost of doing a shift in MODE by BITS and then subtracting
a value when optimizing for SPEED.

References alg_hash_entry::mode, shiftsub0_cost_ptr(), and alg_hash_entry::speed.

Referenced by get_shiftadd_cost(), and synth_mult().

◆ shiftsub0_cost_ptr()

int * shiftsub0_cost_ptr	(	bool	speed,
		machine_mode	mode,
		int	bits )

inline

Subroutine of {set_,}shiftsub0_cost.  Not to be used otherwise.

References expmed_mode_index(), ggc_alloc(), alg_hash_entry::mode, alg_hash_entry::speed, and this_target_expmed.

Referenced by set_shiftsub0_cost(), and shiftsub0_cost().

◆ shiftsub1_cost()

int shiftsub1_cost	(	bool	speed,
		machine_mode	mode,
		int	bits )

inline

Return the cost of subtracting a shift in MODE by BITS from a value
when optimizing for SPEED.

References alg_hash_entry::mode, shiftsub1_cost_ptr(), and alg_hash_entry::speed.

Referenced by get_shiftadd_cost(), and synth_mult().

◆ shiftsub1_cost_ptr()

int * shiftsub1_cost_ptr	(	bool	speed,
		machine_mode	mode,
		int	bits )

inline

Subroutine of {set_,}shiftsub1_cost.  Not to be used otherwise.

References expmed_mode_index(), ggc_alloc(), alg_hash_entry::mode, alg_hash_entry::speed, and this_target_expmed.

Referenced by set_shiftsub1_cost(), and shiftsub1_cost().

◆ smod_pow2_cheap()

bool smod_pow2_cheap	(	bool	speed,
		machine_mode	mode )

inline

Return whether a signed modulo by a power of 2 is cheap in MODE
when optimizing for SPEED.

References alg_hash_entry::mode, smod_pow2_cheap_ptr(), and alg_hash_entry::speed.

Referenced by expand_divmod().

◆ smod_pow2_cheap_ptr()

bool * smod_pow2_cheap_ptr	(	bool	speed,
		machine_mode	mode )

inline

Subroutine of {set_,}smod_pow2_cheap.  Not to be used otherwise.

References expmed_op_cheap_ptr(), alg_hash_entry::mode, alg_hash_entry::speed, and this_target_expmed.

Referenced by set_smod_pow2_cheap(), and smod_pow2_cheap().

◆ store_bit_field()

void store_bit_field	(	rtx	str_rtx,
		poly_uint64	bitsize,
		poly_uint64	bitnum,
		poly_uint64	bitregion_start,
		poly_uint64	bitregion_end,
		machine_mode	fieldmode,
		rtx	value,
		bool	reverse,
		bool	undefined_p )

extern

Generate code to store value from rtx VALUE
into a bit-field within structure STR_RTX
containing BITSIZE bits starting at bit BITNUM.

BITREGION_START is bitpos of the first bitfield in this region.
BITREGION_END is the bitpos of the ending bitfield in this region.
These two fields are 0, if the C++ memory model does not apply,
or we are not interested in keeping track of bitfield regions.

FIELDMODE is the machine-mode of the FIELD_DECL node for this field.

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

If UNDEFINED_P is true then STR_RTX is currently undefined.

References adjust_bitfield_address, adjust_bitfield_address_size, bits_to_bytes_round_up, copy_to_reg(), emit_move_insn(), flip_storage_order(), gcc_assert, gcc_unreachable, get_best_mode(), GET_MODE_BITSIZE(), ggc_alloc(), INT_MAX, poly_int< N, C >::is_constant(), MEM_ALIGN, MEM_P, MEM_VOLATILE_P, narrow_bit_field_mem(), offset, store_bit_field_1(), strict_volatile_bitfield_p(), and expand_operand::value.

Referenced by copy_blkmode_from_reg(), copy_blkmode_to_reg(), emit_group_store(), expand_assignment(), expand_expr_real_2(), noce_emit_move_insn(), store_expr(), store_field(), store_unaligned_arguments_into_pseudos(), and write_complex_part().

◆ udiv_cost()

int udiv_cost	(	bool	speed,
		machine_mode	mode )

inline

Return the cost of doing an unsigned division in MODE when
optimizing for SPEED.

References alg_hash_entry::mode, alg_hash_entry::speed, and udiv_cost_ptr().

Referenced by expand_divmod().

◆ udiv_cost_ptr()

int * udiv_cost_ptr	(	bool	speed,
		machine_mode	mode )

inline

Subroutine of {set_,}udiv_cost.  Not to be used otherwise.

References expmed_op_cost_ptr(), alg_hash_entry::mode, alg_hash_entry::speed, and this_target_expmed.

Referenced by set_udiv_cost(), and udiv_cost().

◆ zero_cost()

int zero_cost ( bool speed )

inline

Return the COST of loading zero when optimizing for SPEED.

References alg_hash_entry::speed, and zero_cost_ptr().

Referenced by synth_mult().

◆ zero_cost_ptr()

int * zero_cost_ptr ( bool speed )

inline

Subroutine of {set_,}zero_cost.  Not to be used otherwise.

References alg_hash_entry::speed, and this_target_expmed.

Referenced by set_zero_cost(), and zero_cost().

Variable Documentation

◆ default_target_expmed

struct target_expmed default_target_expmed

extern

Medium-level subroutines: convert bit-field store and extract
   and shifts, multiplies and divides to rtl instructions.
   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/>.

Work around tree-optimization/91825.

Data Structures

Macros

Enumerations

Functions

Variables

Macro Definition Documentation

◆ CHEAPER_MULT_COST

◆ MULT_COST_LESS

◆ NUM_ALG_HASH_ENTRIES

◆ NUM_MODE_IP_INT

◆ NUM_MODE_IPV_INT

◆ this_target_expmed

Enumeration Type Documentation

◆ alg_code

◆ mult_variant

Function Documentation

◆ add_cost()

◆ add_cost_ptr()

◆ alg_hash_entry_ptr()

◆ alg_hash_used_p()

◆ canonicalize_comparison()

◆ choose_mult_variant()

◆ choose_multiplier()

◆ convert_cost()

◆ convert_cost_ptr()

◆ emit_cstore()

◆ emit_store_flag()

◆ emit_store_flag_force()

◆ expand_and()

◆ expand_mult()

◆ expand_mult_highpart_adjust()

◆ expmed_mode_index()

◆ expmed_mult_highpart_optab()

◆ expmed_op_cheap_ptr()

◆ expmed_op_cost_ptr()

◆ extract_bit_field()

◆ extract_low_bits()

◆ flip_storage_order()

◆ mul_cost()

◆ mul_cost_ptr()

◆ mul_highpart_cost()

◆ mul_highpart_cost_ptr()

◆ mul_widen_cost()

◆ mul_widen_cost_ptr()

◆ mult_by_coeff_cost()

◆ neg_cost()

◆ neg_cost_ptr()

◆ negate_rtx()

◆ sdiv_cost()

◆ sdiv_cost_ptr()

◆ sdiv_pow2_cheap()

◆ sdiv_pow2_cheap_ptr()

◆ set_add_cost()

◆ set_alg_hash_used_p()

◆ set_convert_cost()

◆ set_mul_cost()

◆ set_mul_highpart_cost()

◆ set_mul_widen_cost()

◆ set_neg_cost()

◆ set_sdiv_cost()

◆ set_sdiv_pow2_cheap()

◆ set_shift_cost()

◆ set_shiftadd_cost()

◆ set_shiftsub0_cost()

◆ set_shiftsub1_cost()

◆ set_smod_pow2_cheap()

◆ set_udiv_cost()

◆ set_zero_cost()

◆ shift_cost()

◆ shift_cost_ptr()

◆ shiftadd_cost()

◆ shiftadd_cost_ptr()

◆ shiftsub0_cost()

◆ shiftsub0_cost_ptr()

◆ shiftsub1_cost()

◆ shiftsub1_cost_ptr()

◆ smod_pow2_cheap()

◆ smod_pow2_cheap_ptr()

◆ store_bit_field()

◆ udiv_cost()