GCC Middle and Back End API Reference
machmode.h File Reference
#include "mode-classes.def"
Include dependency graph for machmode.h:
This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures

struct  mode_traits< T >
 
struct  mode_traits< machine_mode >
 
class  opt_mode< T >
 
struct  pod_mode< T >
 
class  scalar_int_mode
 
class  scalar_float_mode
 
class  scalar_mode
 
class  complex_mode
 
class  fixed_size_mode
 
class  bit_field_mode_iterator
 
struct  int_n_data_t
 

Namespaces

namespace  mode_iterator
 

Macros

#define ONLY_FIXED_SIZE_MODES   0
 
#define GET_MODE_NAME(MODE)   mode_name[MODE]
 
#define DEF_MODE_CLASS(M)   M
 
#define GET_MODE_CLASS(MODE)   ((enum mode_class) mode_class[MODE])
 
#define INTEGRAL_MODE_P(MODE)
 
#define FLOAT_MODE_P(MODE)
 
#define COMPLEX_MODE_P(MODE)
 
#define VECTOR_MODE_P(MODE)
 
#define SCALAR_INT_MODE_P(MODE)
 
#define SCALAR_FLOAT_MODE_P(MODE)
 
#define DECIMAL_FLOAT_MODE_P(MODE)    (GET_MODE_CLASS (MODE) == MODE_DECIMAL_FLOAT)
 
#define SCALAR_FRACT_MODE_P(MODE)    (GET_MODE_CLASS (MODE) == MODE_FRACT)
 
#define SCALAR_UFRACT_MODE_P(MODE)    (GET_MODE_CLASS (MODE) == MODE_UFRACT)
 
#define ALL_SCALAR_FRACT_MODE_P(MODE)    (SCALAR_FRACT_MODE_P (MODE) || SCALAR_UFRACT_MODE_P (MODE))
 
#define SCALAR_ACCUM_MODE_P(MODE)    (GET_MODE_CLASS (MODE) == MODE_ACCUM)
 
#define SCALAR_UACCUM_MODE_P(MODE)    (GET_MODE_CLASS (MODE) == MODE_UACCUM)
 
#define ALL_SCALAR_ACCUM_MODE_P(MODE)    (SCALAR_ACCUM_MODE_P (MODE) || SCALAR_UACCUM_MODE_P (MODE))
 
#define SIGNED_SCALAR_FIXED_POINT_MODE_P(MODE)    (SCALAR_FRACT_MODE_P (MODE) || SCALAR_ACCUM_MODE_P (MODE))
 
#define UNSIGNED_SCALAR_FIXED_POINT_MODE_P(MODE)    (SCALAR_UFRACT_MODE_P (MODE) || SCALAR_UACCUM_MODE_P (MODE))
 
#define ALL_SCALAR_FIXED_POINT_MODE_P(MODE)
 
#define FRACT_MODE_P(MODE)
 
#define UFRACT_MODE_P(MODE)
 
#define ALL_FRACT_MODE_P(MODE)    (FRACT_MODE_P (MODE) || UFRACT_MODE_P (MODE))
 
#define ACCUM_MODE_P(MODE)
 
#define UACCUM_MODE_P(MODE)
 
#define ALL_ACCUM_MODE_P(MODE)    (ACCUM_MODE_P (MODE) || UACCUM_MODE_P (MODE))
 
#define SIGNED_FIXED_POINT_MODE_P(MODE)    (FRACT_MODE_P (MODE) || ACCUM_MODE_P (MODE))
 
#define UNSIGNED_FIXED_POINT_MODE_P(MODE)    (UFRACT_MODE_P (MODE) || UACCUM_MODE_P (MODE))
 
#define ALL_FIXED_POINT_MODE_P(MODE)
 
#define OPAQUE_MODE_P(MODE)    (GET_MODE_CLASS (MODE) == MODE_OPAQUE)
 
#define CLASS_HAS_WIDER_MODES_P(CLASS)
 
#define MACHINE_MODE_BITSIZE   16
 
#define GET_MODE_IBIT(MODE)   mode_ibit[MODE]
 
#define GET_MODE_FBIT(MODE)   mode_fbit[MODE]
 
#define GET_MODE_MASK(MODE)   mode_mask_array[MODE]
 
#define GET_MODE_INNER(MODE)   (mode_to_inner (MODE))
 
#define GET_MODE_UNIT_SIZE(MODE)   mode_to_unit_size (MODE)
 
#define GET_MODE_UNIT_BITSIZE(MODE)    ((unsigned short) (GET_MODE_UNIT_SIZE (MODE) * BITS_PER_UNIT))
 
#define GET_MODE_UNIT_PRECISION(MODE)   (mode_to_unit_precision (MODE))
 
#define GET_MODE_COMPLEX_MODE(MODE)   ((machine_mode) mode_complex[MODE])
 
#define MACRO_MODE(MODE)   (MODE)
 
#define GET_MODE_ALIGNMENT(MODE)   get_mode_alignment (MODE)
 
#define GET_CLASS_NARROWEST_MODE(CLASS)    ((machine_mode) class_narrowest_mode[CLASS])
 
#define NARROWEST_INT_MODE
 
#define TRULY_NOOP_TRUNCATION_MODES_P(MODE1, MODE2)
 
#define FOR_EACH_MODE_IN_CLASS(ITERATOR, CLASS)
 
#define FOR_EACH_MODE(ITERATOR, START, END)
 
#define FOR_EACH_MODE_FROM(ITERATOR, START)
 
#define FOR_EACH_WIDER_MODE_FROM(ITERATOR, START)
 
#define FOR_EACH_MODE_UNTIL(ITERATOR, END)    FOR_EACH_MODE (ITERATOR, get_narrowest_mode (END), END)
 
#define FOR_EACH_NEXT_MODE(ITERATOR, START)
 
#define FOR_EACH_WIDER_MODE(ITERATOR, START)
 
#define FOR_EACH_2XWIDER_MODE(ITERATOR, START)
 

Typedefs

typedef opt_mode< machine_mode > opt_machine_mode
 

Enumerations

enum  mode_class { MODE_CLASSES , MAX_MODE_CLASS }
 

Functions

template<typename T >
bool is_a (machine_mode m)
 
template<typename T , typename U >
bool is_a (const opt_mode< U > &m)
 
template<typename T >
T as_a (machine_mode m)
 
template<typename T , typename U >
T as_a (const opt_mode< U > &m)
 
template<typename T >
opt_mode< Tdyn_cast (machine_mode m)
 
template<typename T , typename U >
opt_mode< Tdyn_cast (const opt_mode< U > &m)
 
template<typename T , typename U >
bool is_a (machine_mode m, U *result)
 
ALWAYS_INLINE poly_uint16 mode_to_bytes (machine_mode mode)
 
ALWAYS_INLINE poly_uint16 mode_to_bits (machine_mode mode)
 
ALWAYS_INLINE poly_uint16 mode_to_precision (machine_mode mode)
 
ALWAYS_INLINE scalar_mode mode_to_inner (machine_mode mode)
 
ALWAYS_INLINE unsigned char mode_to_unit_size (machine_mode mode)
 
ALWAYS_INLINE unsigned short mode_to_unit_precision (machine_mode mode)
 
ALWAYS_INLINE poly_uint16 mode_to_nunits (machine_mode mode)
 
ALWAYS_INLINE poly_uint16 GET_MODE_SIZE (machine_mode mode)
 
template<typename T >
ALWAYS_INLINE if_poly< typenameT::measurement_type >::type GET_MODE_SIZE (const T &mode)
 
template<typename T >
ALWAYS_INLINE if_nonpoly< typenameT::measurement_type >::type GET_MODE_SIZE (const T &mode)
 
ALWAYS_INLINE poly_uint16 GET_MODE_BITSIZE (machine_mode mode)
 
template<typename T >
ALWAYS_INLINE if_poly< typenameT::measurement_type >::type GET_MODE_BITSIZE (const T &mode)
 
template<typename T >
ALWAYS_INLINE if_nonpoly< typenameT::measurement_type >::type GET_MODE_BITSIZE (const T &mode)
 
ALWAYS_INLINE poly_uint16 GET_MODE_PRECISION (machine_mode mode)
 
template<typename T >
ALWAYS_INLINE if_poly< typenameT::measurement_type >::type GET_MODE_PRECISION (const T &mode)
 
template<typename T >
ALWAYS_INLINE if_nonpoly< typenameT::measurement_type >::type GET_MODE_PRECISION (const T &mode)
 
ALWAYS_INLINE poly_uint16 GET_MODE_NUNITS (machine_mode mode)
 
template<typename T >
ALWAYS_INLINE if_poly< typenameT::measurement_type >::type GET_MODE_NUNITS (const T &mode)
 
template<typename T >
ALWAYS_INLINE if_nonpoly< typenameT::measurement_type >::type GET_MODE_NUNITS (const T &mode)
 
template<typename T >
ALWAYS_INLINE opt_mode< TGET_MODE_NEXT_MODE (const T &m)
 
template<typename T >
ALWAYS_INLINE opt_mode< TGET_MODE_WIDER_MODE (const T &m)
 
template<typename T >
ALWAYS_INLINE opt_mode< TGET_MODE_2XWIDER_MODE (const T &m)
 
opt_machine_mode mode_for_size (poly_uint64, enum mode_class, int)
 
opt_scalar_int_mode int_mode_for_size (poly_uint64 size, int limit)
 
opt_scalar_float_mode float_mode_for_size (poly_uint64 size)
 
opt_scalar_float_mode decimal_float_mode_for_size (unsigned int size)
 
machine_mode smallest_mode_for_size (poly_uint64, enum mode_class)
 
scalar_int_mode smallest_int_mode_for_size (poly_uint64 size)
 
opt_scalar_int_mode int_mode_for_mode (machine_mode)
 
opt_machine_mode bitwise_mode_for_mode (machine_mode)
 
opt_machine_mode mode_for_vector (scalar_mode, poly_uint64)
 
opt_machine_mode related_vector_mode (machine_mode, scalar_mode, poly_uint64=0)
 
opt_machine_mode related_int_vector_mode (machine_mode)
 
bool get_best_mode (int, int, poly_uint64, poly_uint64, unsigned int, unsigned HOST_WIDE_INT, bool, scalar_int_mode *)
 
unsigned get_mode_alignment (machine_mode)
 
template<typename T >
T get_narrowest_mode (T mode)
 
void init_adjust_machine_modes (void)
 
bool HWI_COMPUTABLE_MODE_P (machine_mode mode)
 
bool HWI_COMPUTABLE_MODE_P (scalar_int_mode mode)
 
template<typename T >
bool is_int_mode (machine_mode mode, T *int_mode)
 
template<typename T >
bool is_float_mode (machine_mode mode, T *float_mode)
 
template<typename T >
bool is_complex_int_mode (machine_mode mode, T *cmode)
 
template<typename T >
bool is_complex_float_mode (machine_mode mode, T *cmode)
 
bool is_narrower_int_mode (machine_mode mode, scalar_int_mode limit)
 
template<typename T >
void mode_iterator::start (opt_mode< T > *iter, enum mode_class mclass)
 
void mode_iterator::start (machine_mode *iter, enum mode_class mclass)
 
template<typename T >
bool mode_iterator::iterate_p (opt_mode< T > *iter)
 
bool mode_iterator::iterate_p (machine_mode *iter)
 
template<typename T >
void mode_iterator::get_next (opt_mode< T > *iter)
 
void mode_iterator::get_next (machine_mode *iter)
 
template<typename T >
void mode_iterator::get_known_next (T *iter)
 
template<typename T >
void mode_iterator::get_wider (opt_mode< T > *iter)
 
void mode_iterator::get_wider (machine_mode *iter)
 
template<typename T >
void mode_iterator::get_known_wider (T *iter)
 
template<typename T >
void mode_iterator::get_2xwider (opt_mode< T > *iter)
 
void mode_iterator::get_2xwider (machine_mode *iter)
 
template<typename T >
void gt_ggc_mx (pod_mode< T > *)
 
template<typename T >
void gt_pch_nx (pod_mode< T > *)
 
template<typename T >
void gt_pch_nx (pod_mode< T > *, gt_pointer_operator, void *)
 

Variables

CONST_MODE_SIZE poly_uint16 mode_size [NUM_MACHINE_MODES]
 
CONST_MODE_PRECISION poly_uint16 mode_precision [NUM_MACHINE_MODES]
 
const unsigned short mode_inner [NUM_MACHINE_MODES]
 
CONST_MODE_NUNITS poly_uint16 mode_nunits [NUM_MACHINE_MODES]
 
CONST_MODE_UNIT_SIZE unsigned char mode_unit_size [NUM_MACHINE_MODES]
 
const unsigned short mode_unit_precision [NUM_MACHINE_MODES]
 
const unsigned short mode_next [NUM_MACHINE_MODES]
 
const unsigned short mode_wider [NUM_MACHINE_MODES]
 
const unsigned short mode_2xwider [NUM_MACHINE_MODES]
 
const char *const mode_name [NUM_MACHINE_MODES]
 
const unsigned char mode_class [NUM_MACHINE_MODES]
 
CONST_MODE_IBIT unsigned char mode_ibit [NUM_MACHINE_MODES]
 
CONST_MODE_FBIT unsigned char mode_fbit [NUM_MACHINE_MODES]
 
CONST_MODE_MASK unsigned HOST_WIDE_INT mode_mask_array [NUM_MACHINE_MODES]
 
const unsigned short mode_complex [NUM_MACHINE_MODES]
 
CONST_MODE_BASE_ALIGN unsigned short mode_base_align [NUM_MACHINE_MODES]
 
const unsigned short class_narrowest_mode [MAX_MODE_CLASS]
 
scalar_int_mode byte_mode
 
scalar_int_mode word_mode
 
scalar_int_mode ptr_mode
 
bool int_n_enabled_p [NUM_INT_N_ENTS]
 
const int_n_data_t int_n_data [NUM_INT_N_ENTS]
 

Macro Definition Documentation

◆ ACCUM_MODE_P

#define ACCUM_MODE_P ( MODE)
Value:
(GET_MODE_CLASS (MODE) == MODE_ACCUM \
|| GET_MODE_CLASS (MODE) == MODE_VECTOR_ACCUM)
#define GET_MODE_CLASS(MODE)
Definition machmode.h:105
Nonzero if MODE is a scalar/vector accum mode.   

◆ ALL_ACCUM_MODE_P

#define ALL_ACCUM_MODE_P ( MODE)     (ACCUM_MODE_P (MODE) || UACCUM_MODE_P (MODE))
Nonzero if MODE is a scalar/vector accum or uaccum mode.   

Referenced by fixed_from_string().

◆ ALL_FIXED_POINT_MODE_P

#define ALL_FIXED_POINT_MODE_P ( MODE)
Value:
#define SIGNED_FIXED_POINT_MODE_P(MODE)
Definition machmode.h:217
#define UNSIGNED_FIXED_POINT_MODE_P(MODE)
Definition machmode.h:221
Nonzero if MODE is a scalar/vector fract, ufract, accum or uaccum mode.   

Referenced by emit_move_insn_1(), expand_expr_real_2(), gen_fixed_libfunc(), gen_fract_conv_libfunc(), gen_fractuns_conv_libfunc(), gen_int_fixed_libfunc(), gen_int_fp_fixed_libfunc(), gen_satfract_conv_libfunc(), gen_satfractuns_conv_libfunc(), make_range_step(), and prepare_cmp_insn().

◆ ALL_FRACT_MODE_P

#define ALL_FRACT_MODE_P ( MODE)     (FRACT_MODE_P (MODE) || UFRACT_MODE_P (MODE))
Nonzero if MODE is a scalar/vector fract or ufract mode.   

Referenced by fixed_from_string(), fold_plusminus_mult_expr(), and avail_exprs_stack::simplify_binary_operation().

◆ ALL_SCALAR_ACCUM_MODE_P

#define ALL_SCALAR_ACCUM_MODE_P ( MODE)     (SCALAR_ACCUM_MODE_P (MODE) || SCALAR_UACCUM_MODE_P (MODE))
Nonzero if MODE is a scalar accum or uaccum mode.   

Referenced by build_minus_one_cst(), build_one_cst(), and convert_to_fixed().

◆ ALL_SCALAR_FIXED_POINT_MODE_P

#define ALL_SCALAR_FIXED_POINT_MODE_P ( MODE)
Value:
#define SIGNED_SCALAR_FIXED_POINT_MODE_P(MODE)
Definition machmode.h:176
#define UNSIGNED_SCALAR_FIXED_POINT_MODE_P(MODE)
Definition machmode.h:180
Nonzero if MODE is a scalar fract, ufract, accum or uaccum mode.   

Referenced by convert_mode_scalar(), and native_decode_rtx().

◆ ALL_SCALAR_FRACT_MODE_P

#define ALL_SCALAR_FRACT_MODE_P ( MODE)     (SCALAR_FRACT_MODE_P (MODE) || SCALAR_UFRACT_MODE_P (MODE))
Nonzero if MODE is a scalar fract or ufract mode.   

◆ CLASS_HAS_WIDER_MODES_P

#define CLASS_HAS_WIDER_MODES_P ( CLASS)
Value:
(CLASS == MODE_INT \
|| CLASS == MODE_PARTIAL_INT \
|| CLASS == MODE_FLOAT \
|| CLASS == MODE_DECIMAL_FLOAT \
|| CLASS == MODE_COMPLEX_FLOAT \
|| CLASS == MODE_FRACT \
|| CLASS == MODE_UFRACT \
|| CLASS == MODE_ACCUM \
|| CLASS == MODE_UACCUM)
Nonzero if CLASS modes can be widened.   

Referenced by expand_binop(), expand_twoval_binop(), expand_twoval_unop(), and expand_unop().

◆ COMPLEX_MODE_P

◆ DECIMAL_FLOAT_MODE_P

◆ DEF_MODE_CLASS

#define DEF_MODE_CLASS ( M)    M
Mode classes.   

◆ FLOAT_MODE_P

◆ FOR_EACH_2XWIDER_MODE

#define FOR_EACH_2XWIDER_MODE ( ITERATOR,
START )
Value:
for ((ITERATOR) = (START), mode_iterator::get_2xwider (&(ITERATOR)); \
mode_iterator::iterate_p (&(ITERATOR)); \
mode_iterator::get_2xwider (&(ITERATOR)))
void get_2xwider(opt_mode< T > *iter)
Definition machmode.h:1190
Make ITERATOR iterate over modes in the same class as MODE, in order
of increasing width, and with each mode being twice the width of the
previous mode.  Start at the mode that is two times wider than START,
or don't iterate at all if there is no such mode.   

Referenced by vectorizable_conversion().

◆ FOR_EACH_MODE

#define FOR_EACH_MODE ( ITERATOR,
START,
END )
Value:
for ((ITERATOR) = (START); \
(ITERATOR) != (END); \
mode_iterator::get_known_next (&(ITERATOR)))
Make ITERATOR iterate over all the modes in the range [START, END),
in order of increasing width.   

Referenced by find_widening_optab_handler_and_mode(), and init_num_sign_bit_copies_in_rep().

◆ FOR_EACH_MODE_FROM

#define FOR_EACH_MODE_FROM ( ITERATOR,
START )
Value:
for ((ITERATOR) = (START); \
mode_iterator::iterate_p (&(ITERATOR)); \
mode_iterator::get_next (&(ITERATOR)))
Make ITERATOR iterate over START and all non-narrower modes in the same
class, in order of increasing width.   

Referenced by bitwise_mode_for_size(), convert_mode_scalar(), copy_blkmode_to_reg(), expand_builtin_strlen(), expand_divmod(), expand_fix(), expand_float(), expand_parity(), expand_sfix_optab(), extract_bit_field_1(), get_best_extraction_insn(), mode_for_vector(), target_supports_divmod_p(), and type_for_widest_vector_mode().

◆ FOR_EACH_MODE_IN_CLASS

◆ FOR_EACH_MODE_UNTIL

#define FOR_EACH_MODE_UNTIL ( ITERATOR,
END )    FOR_EACH_MODE (ITERATOR, get_narrowest_mode (END), END)
Make ITERATOR iterate over modes in the range [NARROWEST, END)
in order of increasing width, where NARROWEST is the narrowest mode
in END's class.   

Referenced by compress_float_constant(), init_expr_target(), init_num_sign_bit_copies_in_rep(), move2add_use_add2_insn(), new_cselib_val(), simplify_compare_const(), and simplify_comparison().

◆ FOR_EACH_NEXT_MODE

#define FOR_EACH_NEXT_MODE ( ITERATOR,
START )
Value:
for ((ITERATOR) = (START), mode_iterator::get_next (&(ITERATOR)); \
mode_iterator::iterate_p (&(ITERATOR)); \
mode_iterator::get_next (&(ITERATOR)))
void get_next(opt_mode< T > *iter)
Definition machmode.h:1138
Make ITERATOR iterate over modes in the same class as MODE, in order
of non-decreasing width.  Start at next such mode after START,
or don't iterate at all if there is no such mode.   

◆ FOR_EACH_WIDER_MODE

#define FOR_EACH_WIDER_MODE ( ITERATOR,
START )
Value:
for ((ITERATOR) = (START), mode_iterator::get_wider (&(ITERATOR)); \
mode_iterator::iterate_p (&(ITERATOR)); \
mode_iterator::get_wider (&(ITERATOR)))
void get_wider(opt_mode< T > *iter)
Definition machmode.h:1164
Make ITERATOR iterate over modes in the same class as MODE, in order
of increasing width.  Start at the first mode wider than START,
or don't iterate at all if there is no wider mode.   

Referenced by cse_insn(), cselib_record_sets(), expand_binop(), expand_twoval_binop(), expand_twoval_unop(), expand_unop(), expression_expensive_p(), prepare_call_arguments(), simplify_comparison(), vt_add_function_parameter(), widen_bswap(), and widen_leading().

◆ FOR_EACH_WIDER_MODE_FROM

#define FOR_EACH_WIDER_MODE_FROM ( ITERATOR,
START )
Value:
for ((ITERATOR) = (START); \
mode_iterator::iterate_p (&(ITERATOR)); \
mode_iterator::get_wider (&(ITERATOR)))
Make ITERATOR iterate over START and all wider modes in the same
class, in order of strictly increasing width.   

Referenced by emit_store_flag_1(), expression_expensive_p(), prepare_cmp_insn(), and prepare_float_lib_cmp().

◆ FRACT_MODE_P

#define FRACT_MODE_P ( MODE)
Value:
(GET_MODE_CLASS (MODE) == MODE_FRACT \
|| GET_MODE_CLASS (MODE) == MODE_VECTOR_FRACT)
Nonzero if MODE is a scalar/vector fract mode.   

◆ GET_CLASS_NARROWEST_MODE

#define GET_CLASS_NARROWEST_MODE ( CLASS)     ((machine_mode) class_narrowest_mode[CLASS])

◆ GET_MODE_ALIGNMENT

#define GET_MODE_ALIGNMENT ( MODE)    get_mode_alignment (MODE)

Referenced by adjust_address_1(), align_local_variable(), alignment_for_piecewise_move(), alter_reg(), apply_args_size(), apply_result_size(), asan_emit_stack_protection(), assign_parm_adjust_stack_rtl(), assign_parm_setup_reg(), assign_parm_setup_stack(), assign_parms(), assign_stack_local_1(), build_constant_desc(), by_pieces_ninsns(), can_store_by_pieces(), compute_record_mode(), copy_blkmode_from_reg(), default_static_rtx_alignment(), default_vector_alignment(), emit_group_load_1(), emit_group_store(), emit_move_insn(), emit_push_insn(), expand_assignment(), expand_builtin_apply(), expand_builtin_apply_args_1(), expand_builtin_init_descriptor(), expand_builtin_return(), expand_expr_real_1(), expand_one_ssa_partition(), expand_one_var(), expand_stack_vars(), expand_used_vars(), fill_vector_of_new_param_types(), finalize_type_size(), fold_builtin_atomic_always_lock_free(), gen_reg_rtx(), get_best_mode(), get_builtin_sync_mem(), get_stack_local_alignment(), gimple_fold_builtin_memory_op(), init_emit_regs(), initialize_sizetypes(), insert_restore(), insert_save(), layout_decl(), layout_type(), lower_oacc_reductions(), make_extraction(), may_be_unaligned_p(), bit_field_mode_iterator::next_mode(), offsettable_address_addr_space_p(), output_constant(), compare_by_pieces_d::prepare_mode(), move_by_pieces_d::prepare_mode(), store_by_pieces_d::prepare_mode(), result_vector(), set_parm_rtl(), simple_mem_bitfield_p(), simplify_operand_subreg(), simplify_context::simplify_subreg(), spill_slot_alignment(), store_constructor_field(), store_field(), and validate_subreg().

◆ GET_MODE_CLASS

#define GET_MODE_CLASS ( MODE)    ((enum mode_class) mode_class[MODE])

Referenced by add_const_value_attribute(), assemble_integer(), assign_parm_setup_reg(), bitwise_mode_for_mode(), build_vector_type_for_mode(), can_mult_highpart_p(), canon_condition(), canonicalize_condition(), cc_in_cond(), combine_simplify_rtx(), compare_and_jump_seq(), compute_can_copy(), compute_record_mode(), const_double_operand(), const_vec_series_p_1(), contains_ccmode_rtx_p(), convert_mode_scalar(), cse_insn(), default_scalar_mode_supported_p(), default_secondary_memory_needed_mode(), do_jump_1(), do_SUBST(), emit_cmp_and_jump_insn_1(), emit_move_complex(), emit_move_insn_1(), emit_push_insn(), emit_store_flag(), emit_store_flag_1(), emit_store_flag_force(), expand_abs(), expand_abs_nojump(), expand_binop(), expand_complex_libcall(), expand_debug_expr(), expand_divmod(), expand_expr_real_1(), expand_expr_real_2(), expand_mult(), expand_parity(), expand_speculation_safe_value(), expand_twoval_binop(), expand_twoval_unop(), expand_unop(), expand_vec_perm_1(), expmed_mode_index(), extract_bit_field_1(), extract_low_bits(), rtx_vector_builder::find_cached_value(), find_cc_set(), find_comparison_args(), find_sets_in_insn(), find_split_point(), find_widening_optab_handler_and_mode(), fold_rtx(), force_to_mode(), gen_extend_conv_libfunc(), gen_fp_libfunc(), gen_fp_to_int_conv_libfunc(), gen_fract_conv_libfunc(), gen_fractuns_conv_libfunc(), gen_int_fp_fixed_libfunc(), gen_int_fp_libfunc(), gen_int_fp_signed_fixed_libfunc(), gen_int_to_fp_conv_libfunc(), gen_int_to_fp_nondecimal_conv_libfunc(), gen_intv_fp_libfunc(), gen_memset_value_from_prev(), gen_reg_rtx(), gen_satfract_conv_libfunc(), gen_satfractuns_conv_libfunc(), gen_trunc_conv_libfunc(), general_operand(), get_narrowest_mode(), get_stored_val(), gimple_expand_vec_cond_expr(), hash_rtx(), immediate_operand(), scalar_mode::includes_p(), init_derived_machine_modes(), init_emit_once(), init_expmed_one_conv(), init_expmed_one_mode(), int_mode_for_mode(), invariant_p(), is_complex_float_mode(), is_complex_int_mode(), is_float_mode(), is_int_mode(), layout_decl(), loc_descriptor(), lto_input_mode_table(), lto_write_mode_table(), mode_for_vector(), move_plus_up(), mul_highpart_cost_ptr(), mul_widen_cost_ptr(), native_decode_vector_rtx(), native_encode_rtx(), noce_emit_cmove(), noce_get_condition(), nonzero_bits1(), omp_clause_aligned_alignment(), omp_max_vf(), output_constant_pool_2(), precompute_arguments(), prepare_call_arguments(), prepare_cmp_insn(), record_value_for_reg(), reg_nonzero_bits_for_combine(), reg_subword_p(), replace_reg_with_saved_mem(), reversed_comparison_code_parts(), safe_predicate_mode(), simple_move(), simple_reg_p(), simplify_context::simplify_binary_operation_1(), simplify_comparison(), simplify_const_relational_operation(), simplify_const_unary_operation(), simplify_if_then_else(), simplify_immed_subreg(), simplify_context::simplify_relational_operation(), simplify_set(), simplify_shift_const_1(), simplify_context::simplify_subreg(), simplify_subreg_concatn(), simplify_subreg_regno(), simplify_context::simplify_unary_operation_1(), simplify_vector_constructor(), split_double(), store_constructor(), store_expr(), store_field(), store_integral_bit_field(), try_combine(), update_rsp_from_reg_equal(), vec_perm_indices_to_rtx(), vect_get_loop_mask(), vect_set_loop_condition_partial_vectors_avx512(), vect_verify_full_masking_avx512(), and vt_add_function_parameter().

◆ GET_MODE_COMPLEX_MODE

#define GET_MODE_COMPLEX_MODE ( MODE)    ((machine_mode) mode_complex[MODE])

◆ GET_MODE_FBIT

◆ GET_MODE_IBIT

◆ GET_MODE_INNER

#define GET_MODE_INNER ( MODE)    (mode_to_inner (MODE))
Return the mode of the basic parts of MODE.  For vector modes this is the
mode of the vector elements.  For complex modes it is the mode of the real
and imaginary parts.  For other modes it is MODE itself.   

Referenced by add_const_value_attribute(), rtx_vector_builder::allow_steps_p(), rtx_vector_builder::apply_step(), assign_parm_setup_reg(), assign_parms_unsplit_complex(), avoid_type_punning_on_regs(), bitwise_mode_for_mode(), bitwise_mode_for_size(), bitwise_type_for_mode(), builtin_memset_gen_str(), builtin_memset_read_str(), can_vec_set_var_idx_p(), clear_storage_hints(), const_vec_series_p_1(), const_vector_elt(), const_vector_from_tree(), const_vector_int_elt(), const_vector_mask_from_tree(), cse_insn(), emit_move_complex(), emit_move_complex_push(), exact_int_to_float_conversion_p(), expand_arith_overflow_result_store(), expand_assignment(), expand_binop(), expand_debug_expr(), expand_expr_real_1(), expand_expr_real_2(), expand_mult_const(), expand_shift_1(), expand_vec_series_expr(), expand_vec_set_optab_fn(), expand_vector_broadcast(), extract_bit_field_1(), rtx_vector_builder::find_cached_value(), flip_storage_order(), fold_const_call_1(), fold_const_call_1(), gen_const_vec_series(), gen_const_vector(), gen_reg_rtx(), init_emit_once(), loc_descriptor(), lto_input_mode_table(), lto_write_mode_table(), maybe_legitimize_operand(), mode_for_vector(), native_decode_vector_rtx(), native_encode_rtx(), output_constant_pool_2(), plus_constant(), qimode_for_vec_perm(), read_complex_part(), related_int_vector_mode(), selector_fits_mode_p(), simplify_context::simplify_binary_operation_1(), simplify_context::simplify_binary_operation_series(), simplify_const_binary_operation(), simplify_const_unary_operation(), simplify_const_vector_subreg(), simplify_context::simplify_gen_vec_select(), simplify_shift_const_1(), simplify_context::simplify_subreg(), simplify_subreg_concatn(), simplify_context::simplify_unary_operation_1(), op_by_pieces_d::smallest_fixed_size_mode_for_size(), rtx_vector_builder::step(), store_bit_field_1(), store_constructor(), subreg_get_info(), supportable_widening_operation(), synth_mult(), type_for_widest_vector_mode(), validate_pattern(), validate_subreg(), vec_perm_indices_to_rtx(), vect_analyze_loop_1(), vect_chooses_same_modes_p(), vect_slp_region(), widest_fixed_size_mode_for_size(), and write_complex_part().

◆ GET_MODE_MASK

#define GET_MODE_MASK ( MODE)    mode_mask_array[MODE]

Referenced by can_vec_perm_var_p(), canonicalize_condition(), clear_storage(), combine_set_extension(), combine_simplify_rtx(), determine_block_size(), do_negate(), do_plus_minus(), doloop_simplify_count(), emit_block_move(), emit_block_move_via_pattern(), expand_compound_operation(), expand_mult_const(), expand_vec_perm_var(), expand_vector_divmod(), expmed_mult_highpart(), force_int_to_mode(), force_to_mode(), iv_number_of_iterations(), loc_list_from_tree_1(), low_bitmask_len(), make_compound_operation_int(), make_extraction(), make_field_assignment(), mem_loc_descriptor(), merge_outer_ops(), minmax_loc_descriptor(), move2add_use_add2_insn(), native_encode_rtx(), noce_try_bitop(), nonzero_bits(), nonzero_bits1(), num_sign_bit_copies1(), output_constant_pool_2(), prepare_cmp_insn(), record_dead_and_set_regs_1(), record_promoted_value(), reg_nonzero_bits_for_combine(), rotate_loc_descriptor(), scompare_loc_descriptor_narrow(), selector_fits_mode_p(), set_nonzero_bits_and_sign_copies(), set_storage_via_setmem(), sign_extend_short_imm(), simplify_and_const_int_1(), simplify_context::simplify_binary_operation_1(), simplify_compare_const(), simplify_comparison(), simplify_const_relational_operation(), simplify_if_then_else(), simplify_shift_const_1(), simplify_context::simplify_truncation(), simplify_context::simplify_unary_operation_1(), synth_mult(), try_combine(), try_widen_shift_mode(), ucompare_loc_descriptor(), update_reg_equal_equiv_notes(), val_signbit_p(), vect_recog_divmod_pattern(), and vectorizable_operation().

◆ GET_MODE_NAME

◆ GET_MODE_UNIT_BITSIZE

◆ GET_MODE_UNIT_PRECISION

◆ GET_MODE_UNIT_SIZE

◆ INTEGRAL_MODE_P

◆ MACHINE_MODE_BITSIZE

#define MACHINE_MODE_BITSIZE   16
The MACHINE_MODE_BITSIZE should be exactly aligned with the type of the
machine_mode array in the machmode.h and genmodes.cc.  For example as below.
+------------------------+-------+
| MACHINE_MODE_BITSIZE   |    16 |
+------------------------+-------+
| mode_inter[]           | short |
| mode_next[]            | short |
| mode_wider[]           | short |
| mode_2xwider[]         | short |
| mode_complex[]         | short |
| class_narrowest_mode[] | short |
+------------------------+-------+

Referenced by subreg_shape::unique_id().

◆ MACRO_MODE

#define MACRO_MODE ( MODE)    (MODE)
Wrapper for mode arguments to target macros, so that if a target
doesn't need polynomial-sized modes, its header file can continue
to treat everything as fixed_size_mode.  This should go away once
macros are moved to target hooks.  It shouldn't be used in other
contexts.   

Referenced by base_reg_class(), default_class_max_nregs(), default_libcall_value(), default_memory_move_cost(), default_register_move_cost(), default_secondary_reload(), and ok_for_base_p_1().

◆ NARROWEST_INT_MODE

#define NARROWEST_INT_MODE
Value:
Definition machmode.h:427
mode_traits< scalar_int_mode >::from_int from_int
Definition machmode.h:429
const unsigned short class_narrowest_mode[MAX_MODE_CLASS]
The narrowest full integer mode available on the target.   

Referenced by alignment_for_piecewise_move(), push_block(), simplify_using_ranges::simplify_float_conversion_using_ranges(), and widest_fixed_size_mode_for_size().

◆ ONLY_FIXED_SIZE_MODES

#define ONLY_FIXED_SIZE_MODES   0
Always treat machine modes as fixed-size while compiling code specific
to targets that have no variable-size modes.   

◆ OPAQUE_MODE_P

#define OPAQUE_MODE_P ( MODE)     (GET_MODE_CLASS (MODE) == MODE_OPAQUE)
Nonzero if MODE is opaque.   

Referenced by find_moveable_pseudos(), and verify_opaque_type().

◆ SCALAR_ACCUM_MODE_P

#define SCALAR_ACCUM_MODE_P ( MODE)     (GET_MODE_CLASS (MODE) == MODE_ACCUM)
Nonzero if MODE is a scalar accum mode.   

Referenced by mode_for_vector(), and type_for_widest_vector_mode().

◆ SCALAR_FLOAT_MODE_P

◆ SCALAR_FRACT_MODE_P

#define SCALAR_FRACT_MODE_P ( MODE)     (GET_MODE_CLASS (MODE) == MODE_FRACT)
Nonzero if MODE is a scalar fract mode.   

Referenced by mode_for_vector(), and type_for_widest_vector_mode().

◆ SCALAR_INT_MODE_P

#define SCALAR_INT_MODE_P ( MODE)
Value:
(GET_MODE_CLASS (MODE) == MODE_INT \
|| GET_MODE_CLASS (MODE) == MODE_PARTIAL_INT)
Nonzero if MODE is a scalar integral mode.   

Referenced by add_mask_and_len_args(), address_operand(), assign_parm_setup_stack(), avoid_type_punning_on_regs(), canonicalize_comparison(), change_zero_ext(), combine_instructions(), constrain_operands(), convert_extracted_bit_field(), convert_float_to_wider_int(), convert_wider_int_to_float(), create_new_invariant(), cse_insn(), do_compare_rtx_and_jump(), do_store_flag(), emit_group_load_1(), emit_group_store(), expand_call(), expand_debug_expr(), expand_expr_divmod(), expand_expr_real_1(), expand_expr_real_2(), expand_fn_using_insn(), expand_mult(), expand_mult_const(), expand_shift_1(), expand_unop(), expand_value_return(), expand_vector_comparison(), expand_vector_condition(), expand_widen_pattern_expr(), extract_bit_field_1(), find_args_size_adjust(), fold_const_call_1(), fold_const_call_1(), force_to_mode(), gen_lowpart_for_combine(), gen_lowpart_or_truncate(), get_related_vectype_for_scalar_type(), HWI_COMPUTABLE_MODE_P(), if_then_else_cond(), implies_p(), scalar_int_mode::includes_p(), lra_substitute_pseudo(), mem_loc_descriptor(), narrowing_initializer_constant_valid_p(), noce_emit_store_flag(), precompute_register_parameters(), relational_result(), reload_cse_move2add_invalidate(), resolve_simple_move(), reverse_op(), rtl_for_decl_location(), simple_move(), simplify_context::simplify_binary_operation_1(), simplify_operand_subreg(), simplify_context::simplify_relational_operation_1(), simplify_set(), simplify_context::simplify_subreg(), simplify_context::simplify_truncation(), store_constructor(), store_expr(), supportable_narrowing_operation(), supportable_widening_operation(), trunc_int_for_mode(), try_const_anchors(), vectorizable_load(), vectorizable_simd_clone_call(), and vectorizable_store().

◆ SCALAR_UACCUM_MODE_P

#define SCALAR_UACCUM_MODE_P ( MODE)     (GET_MODE_CLASS (MODE) == MODE_UACCUM)
Nonzero if MODE is a scalar uaccum mode.   

Referenced by mode_for_vector(), and type_for_widest_vector_mode().

◆ SCALAR_UFRACT_MODE_P

#define SCALAR_UFRACT_MODE_P ( MODE)     (GET_MODE_CLASS (MODE) == MODE_UFRACT)
Nonzero if MODE is a scalar ufract mode.   

Referenced by mode_for_vector(), and type_for_widest_vector_mode().

◆ SIGNED_FIXED_POINT_MODE_P

◆ SIGNED_SCALAR_FIXED_POINT_MODE_P

#define SIGNED_SCALAR_FIXED_POINT_MODE_P ( MODE)     (SCALAR_FRACT_MODE_P (MODE) || SCALAR_ACCUM_MODE_P (MODE))
Nonzero if MODE is a scalar fract or accum mode.   

Referenced by fixed_from_double_int().

◆ TRULY_NOOP_TRUNCATION_MODES_P

◆ UACCUM_MODE_P

#define UACCUM_MODE_P ( MODE)
Value:
(GET_MODE_CLASS (MODE) == MODE_UACCUM \
|| GET_MODE_CLASS (MODE) == MODE_VECTOR_UACCUM)
Nonzero if MODE is a scalar/vector uaccum mode.   

◆ UFRACT_MODE_P

#define UFRACT_MODE_P ( MODE)
Value:
(GET_MODE_CLASS (MODE) == MODE_UFRACT \
|| GET_MODE_CLASS (MODE) == MODE_VECTOR_UFRACT)
Nonzero if MODE is a scalar/vector ufract mode.   

◆ UNSIGNED_FIXED_POINT_MODE_P

◆ UNSIGNED_SCALAR_FIXED_POINT_MODE_P

#define UNSIGNED_SCALAR_FIXED_POINT_MODE_P ( MODE)     (SCALAR_UFRACT_MODE_P (MODE) || SCALAR_UACCUM_MODE_P (MODE))
Nonzero if MODE is a scalar ufract or uaccum mode.   

Referenced by fixed_from_double_int().

◆ VECTOR_MODE_P

#define VECTOR_MODE_P ( MODE)
Value:
(GET_MODE_CLASS (MODE) == MODE_VECTOR_BOOL \
|| GET_MODE_CLASS (MODE) == MODE_VECTOR_INT \
|| GET_MODE_CLASS (MODE) == MODE_VECTOR_FLOAT \
|| GET_MODE_CLASS (MODE) == MODE_VECTOR_FRACT \
|| GET_MODE_CLASS (MODE) == MODE_VECTOR_UFRACT \
|| GET_MODE_CLASS (MODE) == MODE_VECTOR_ACCUM \
|| GET_MODE_CLASS (MODE) == MODE_VECTOR_UACCUM)
Nonzero if MODE is a vector mode.   

Referenced by add_removable_extension(), bitwise_mode_for_mode(), bitwise_type_for_mode(), build_truth_vector_type_for(), build_truth_vector_type_for_mode(), builtin_memset_gen_str(), builtin_memset_read_str(), by_pieces_mode_supported_p(), can_duplicate_and_interleave_p(), can_store_by_pieces(), can_vec_extract(), can_vec_extract_var_idx_p(), can_vec_mask_load_store_p(), can_vec_perm_const_p(), can_vec_perm_var_p(), can_vec_set_var_idx_p(), check_load_store_for_partial_vectors(), comparison_code_valid_for_mode(), convert_modes(), convert_move(), default_vectorize_related_mode(), expand_binop_directly(), expand_expr_real_1(), expand_expr_real_2(), expand_shift_1(), expand_vector_broadcast(), expand_vector_conversion(), expand_vector_operation(), expand_vector_operations_1(), expand_vector_scalar_condition(), expand_vector_ubsan_overflow(), expand_while_optab_fn(), extract_bit_field_1(), fold_rtx(), gen_memset_value_from_prev(), get_compute_type(), get_inner_reference(), get_len_load_store_mode(), get_related_vectype_for_scalar_type(), get_stored_val(), gimple_expand_vec_cond_expr(), ifcvt_can_use_mask_load_store(), known_cond(), maybe_legitimize_operand(), native_decode_rtx(), process_alt_operands(), related_int_vector_mode(), related_vector_mode(), relational_result(), rtl_for_decl_init(), signed_or_unsigned_type_for(), simplify_context::simplify_binary_operation_1(), simplify_const_binary_operation(), simplify_const_unary_operation(), simplify_context::simplify_gen_vec_select(), simplify_context::simplify_merge_mask(), simplify_context::simplify_subreg(), simplify_subreg_concatn(), simplify_context::simplify_ternary_operation(), simplify_context::simplify_unary_operation_1(), simplify_vector_constructor(), store_bit_field_1(), store_constructor(), supportable_convert_operation(), supportable_half_widening_operation(), supportable_widening_operation(), supports_vec_convert_optab_p(), undistribute_bitref_for_vector(), validate_pattern(), validate_subreg(), vec_duplicate_p(), vect_analyze_loop_1(), vect_chooses_same_modes_p(), vect_create_epilog_for_reduction(), vect_emulated_vector_p(), vect_get_vector_types_for_stmt(), vect_grouped_load_supported(), vect_grouped_store_supported(), vect_model_reduction_cost(), vect_recog_bool_pattern(), vect_slp_region(), vect_synth_mult_by_constant(), vector_type_mode(), vector_vector_composition_type(), vectorizable_load(), vectorizable_shift(), vectorizable_store(), and vectorized_internal_fn_supported_p().

Typedef Documentation

◆ opt_machine_mode

typedef opt_mode<machine_mode> opt_machine_mode
Machine mode definitions for GCC; included by rtl.h and tree.h.
   Copyright (C) 1991-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/>.   

Enumeration Type Documentation

◆ mode_class

enum mode_class
Enumerator
MODE_CLASSES 
MAX_MODE_CLASS 

Function Documentation

◆ as_a() [1/2]

template<typename T , typename U >
T as_a ( const opt_mode< U > & m)
inline

◆ as_a() [2/2]

template<typename T >
T as_a ( machine_mode m)
inline
Assert that mode M has type T, and return it in that form.   

References gcc_checking_assert.

Referenced by as_a(), and smallest_int_mode_for_size().

◆ bitwise_mode_for_mode()

opt_machine_mode bitwise_mode_for_mode ( machine_mode mode)
extern
Find a mode that can be used for efficient bitwise operations on MODE,
if one exists.   

References COMPLEX_MODE_P, gcc_checking_assert, GET_MODE_BITSIZE(), GET_MODE_CLASS, GET_MODE_INNER, have_regs_of_mode, int_mode_for_mode(), is_a(), MAX_FIXED_MODE_SIZE, maybe_gt, mode_for_size(), targetm, and VECTOR_MODE_P.

Referenced by bitwise_type_for_mode().

◆ decimal_float_mode_for_size()

opt_scalar_float_mode decimal_float_mode_for_size ( unsigned int size)
inline
Likewise for MODE_DECIMAL_FLOAT.   

References dyn_cast(), and mode_for_size().

◆ dyn_cast() [1/2]

template<typename T , typename U >
opt_mode< T > dyn_cast ( const opt_mode< U > & m)
inline

◆ dyn_cast() [2/2]

template<typename T >
opt_mode< T > dyn_cast ( machine_mode m)
inline
Convert M to an opt_mode<T>.   

References T.

Referenced by decimal_float_mode_for_size(), dyn_cast(), float_mode_for_size(), and int_mode_for_size().

◆ float_mode_for_size()

opt_scalar_float_mode float_mode_for_size ( poly_uint64 size)
inline
Return the machine mode to use for a MODE_FLOAT of SIZE bits, if one
exists.   

References dyn_cast(), and mode_for_size().

Referenced by init_emit_once(), and layout_type().

◆ get_best_mode()

bool get_best_mode ( int bitsize,
int bitpos,
poly_uint64 bitregion_start,
poly_uint64 bitregion_end,
unsigned int align,
unsigned HOST_WIDE_INT largest_mode_bitsize,
bool volatilep,
scalar_int_mode * best_mode )
extern
Find the best mode to use to access a bit field.   
Find the best machine mode to use when referencing a bit field of length
BITSIZE bits starting at BITPOS.

BITREGION_START is the bit position of the first bit in this
sequence of bit fields.  BITREGION_END is the last bit in this
sequence.  If these two fields are non-zero, we should restrict the
memory access to that range.  Otherwise, we are allowed to touch
any adjacent non bit-fields.

The chosen mode must have no more than LARGEST_MODE_BITSIZE bits.
INT_MAX is a suitable value for LARGEST_MODE_BITSIZE if the caller
doesn't want to apply a specific limit.

If no mode meets all these conditions, we return VOIDmode.

The underlying object is known to be aligned to a boundary of ALIGN bits.

If VOLATILEP is false and SLOW_BYTE_ACCESS is false, we return the
smallest mode meeting these conditions.

If VOLATILEP is false and SLOW_BYTE_ACCESS is true, we return the
largest mode (but a mode no wider than UNITS_PER_WORD) that meets
all the conditions.

If VOLATILEP is true the narrow_volatile_bitfields target hook is used to
decide which of the above modes should be used.   

References GET_MODE_ALIGNMENT, GET_MODE_BITSIZE(), bit_field_mode_iterator::next_mode(), and bit_field_mode_iterator::prefer_smaller_modes().

Referenced by extract_fixed_bit_field(), fold_truth_andor_1(), optimize_bit_field_compare(), optimize_bitfield_assignment_op(), store_bit_field(), and store_fixed_bit_field().

◆ GET_MODE_2XWIDER_MODE()

template<typename T >
ALWAYS_INLINE opt_mode< T > GET_MODE_2XWIDER_MODE ( const T & m)
For scalars, this is a mode with twice the precision.  For vectors,
this is a mode with the same inner mode but with twice the elements.   

References mode_2xwider.

Referenced by expand_binop(), expand_expr_real_2(), expand_mul_overflow(), mode_iterator::get_2xwider(), mode_iterator::get_2xwider(), init_lower_subreg(), and init_sync_libfuncs_1().

◆ get_mode_alignment()

unsigned get_mode_alignment ( machine_mode mode)
extern
Return the alignment of MODE. This will be bounded by 1 and
BIGGEST_ALIGNMENT.   

References MAX, MIN, and mode_base_align.

Referenced by emit_move_complex().

◆ GET_MODE_BITSIZE() [1/3]

template<typename T >
ALWAYS_INLINE if_poly< typenameT::measurement_type >::type GET_MODE_BITSIZE ( const T & mode)

References mode_to_bits().

◆ GET_MODE_BITSIZE() [2/3]

template<typename T >
ALWAYS_INLINE if_nonpoly< typenameT::measurement_type >::type GET_MODE_BITSIZE ( const T & mode)

◆ GET_MODE_BITSIZE() [3/3]

ALWAYS_INLINE poly_uint16 GET_MODE_BITSIZE ( machine_mode mode)
Get the size in bits of an object of mode MODE.   

References mode_to_bits().

Referenced by adjust_bit_field_mem_for_reg(), adjust_bool_pattern(), alter_reg(), ao_ref_init_from_vn_reference(), append_pattern_def_seq(), tree_switch_conversion::switch_conversion::array_value_type(), assign_parm_setup_reg(), avoid_type_punning_on_regs(), bitwise_mode_for_mode(), bitwise_mode_for_size(), bswap_loc_descriptor(), build_common_tree_nodes(), build_index_vector(), build_vector_type_for_mode(), can_duplicate_and_interleave_p(), can_mult_highpart_p(), can_vec_extract(), canonicalize_address_mult(), canonicalize_iv_subregs(), check_bool_pattern(), clz_loc_descriptor(), compute_record_mode(), convert_mode_scalar(), convert_modes(), convert_move(), copy_blkmode_from_reg(), copy_blkmode_to_reg(), dead_debug_insert_temp(), default_secondary_memory_needed_mode(), delegitimize_mem_from_attrs(), do_compare_and_jump(), emit_block_cmp_via_loop(), emit_block_move_via_loop(), emit_block_move_via_oriented_loop(), emit_block_move_via_pattern(), emit_cstore(), emit_group_store(), emit_move_insn_1(), emit_store_flag_1(), emit_store_flag_int(), expand_absneg_bit(), expand_assignment(), expand_binop(), expand_builtin_issignaling(), expand_builtin_signbit(), expand_copysign_absneg(), expand_copysign_bit(), expand_debug_expr(), expand_divmod(), expand_doubleword_clz_ctz_ffs(), expand_expr_addr_expr_1(), expand_expr_real_1(), expand_expr_real_2(), expand_field_assignment(), expand_fix(), expand_float(), expand_function_end(), expand_misaligned_mem_ref(), expand_mult_highpart_adjust(), expand_omp_atomic(), expand_sdiv_pow2(), expand_shift_1(), expand_single_bit_test(), expand_smod_pow2(), expand_twoval_binop_libfunc(), expand_unop(), expand_vector_comparison(), expand_vector_condition(), expmed_mult_highpart(), expmed_mult_highpart_optab(), extract_bit_field(), extract_bit_field_1(), extract_bit_field_as_subreg(), extract_bit_field_using_extv(), extract_fixed_bit_field_1(), extract_high_half(), extract_integral_bit_field(), extract_low_bits(), find_bitfield_repr_type(), find_reloads(), find_shift_sequence(), finish_bitfield_representative(), fixed_from_double_int(), fold_nonarray_ctor_reference(), fold_truth_andor_1(), frame_offset_overflow(), gen_int_libfunc(), get_best_mode(), get_inner_reference(), get_ref_base_and_extent(), get_related_vectype_for_scalar_type(), get_section_anchor(), get_shiftadd_cost(), get_stored_val(), gimple_fold_builtin_memory_op(), gimple_fold_builtin_memset(), strlen_pass::handle_builtin_memcmp(), immed_double_const(), init_derived_machine_modes(), instrument_bool_enum_load(), instrument_si_overflow(), int_mode_for_mode(), iv_number_of_iterations(), iv_subreg(), layout_type(), loc_list_from_tree_1(), lowpart_bit_field_p(), make_compound_operation_int(), make_extraction(), match_arith_overflow(), maybe_optimize_mod_cmp(), maybe_optimize_pow2p_mod_cmp(), mem_loc_descriptor(), merge_ranges(), mergeable_constant_section(), mergeable_string_section(), mode_for_vector(), narrow_bit_field_mem(), native_decode_rtx(), native_encode_fixed(), bit_field_mode_iterator::next_mode(), noce_emit_move_insn(), noce_try_bitop(), optimize_atomic_compare_exchange_p(), optimize_bit_field_compare(), optimize_bitfield_assignment_op(), optimize_range_tests_to_bit_test(), output_constant_pool_1(), output_constant_pool_2(), predicate_statements(), prepare_call_arguments(), prepare_cmp_insn(), read_complex_part(), replace_reg_with_saved_mem(), rotate_loc_descriptor(), scompare_loc_descriptor_narrow(), set_storage_via_setmem(), shift_return_value(), signed_or_unsigned_type_for(), simd_clone_adjust(), simd_clone_adjust_argument_types(), simd_clone_adjust_return_type(), simple_mem_bitfield_p(), simple_move(), simplify_and_const_int_1(), simplify_context::simplify_binary_operation_1(), simplify_comparison(), simplify_shift_const_1(), simplify_context::simplify_subreg(), simplify_context::simplify_truncation(), simplify_while_replacing(), store_bit_field(), store_bit_field_1(), store_bit_field_using_insv(), store_constructor(), store_expr(), store_field(), store_fixed_bit_field(), store_fixed_bit_field_1(), store_integral_bit_field(), store_split_bit_field(), strict_volatile_bitfield_p(), synth_mult(), try_casesi(), ubsan_encode_value(), undistribute_bitref_for_vector(), unextend(), validate_test_and_branch(), vect_determine_mask_precision(), vect_lanes_optab_supported_p(), vect_recog_cast_forwprop_pattern(), vect_recog_divmod_pattern(), vect_recog_mixed_size_cond_pattern(), vect_truncate_gather_scatter_offset(), vect_verify_full_masking(), vect_verify_full_masking_avx512(), vect_verify_loop_lens(), vector_type_mode(), vector_vector_composition_type(), vectorizable_conversion(), vectorizable_operation(), vectorizable_simd_clone_call(), vectorizable_store(), verify_gimple_assign_ternary(), verify_types_in_gimple_reference(), widen_bswap(), and write_complex_part().

◆ GET_MODE_NEXT_MODE()

template<typename T >
ALWAYS_INLINE opt_mode< T > GET_MODE_NEXT_MODE ( const T & m)
Get the next natural mode (not narrower, eg, QI -> HI -> SI -> DI -> TI
or HF -> BF -> SF -> DF -> XF -> TF).   

References mode_next.

Referenced by mode_iterator::get_known_next(), mode_iterator::get_next(), and mode_iterator::get_next().

◆ GET_MODE_NUNITS() [1/3]

template<typename T >
ALWAYS_INLINE if_poly< typenameT::measurement_type >::type GET_MODE_NUNITS ( const T & mode)

References mode_to_nunits().

◆ GET_MODE_NUNITS() [2/3]

template<typename T >
ALWAYS_INLINE if_nonpoly< typenameT::measurement_type >::type GET_MODE_NUNITS ( const T & mode)

◆ GET_MODE_NUNITS() [3/3]

ALWAYS_INLINE poly_uint16 GET_MODE_NUNITS ( machine_mode mode)
Get the number of units in an object of mode MODE.  This is 2 for
complex modes and the number of elements for vector modes.   

References mode_to_nunits().

Referenced by rtx_vector_builder::build(), build_vector_type_for_mode(), can_duplicate_and_interleave_p(), can_mult_highpart_p(), can_vec_perm_var_p(), expand_binop_directly(), expand_mult_highpart(), expand_vec_cond_expr_p(), expand_vec_perm_const(), expand_vec_perm_var(), expand_vector_broadcast(), find_sets_in_insn(), gen_rtx_CONST_VECTOR(), gimple_expand_vec_cond_expr(), gimple_fold_partial_load_store_mem_ref(), have_whole_vector_shift(), lto_input_mode_table(), lto_write_mode_table(), may_trap_p_1(), maybe_swap_commutative_operands(), mode_for_vector(), native_decode_rtx(), native_decode_vector_rtx(), native_encode_rtx(), rtx_vector_builder::new_vector(), omp_max_vf(), output_constant_pool_2(), rtx_writer::print_rtx_operand_codes_E_and_V(), related_int_vector_mode(), rtx_vector_builder::shape_nelts(), shift_amt_for_vec_perm_mask(), simplify_context::simplify_binary_operation_1(), simplify_const_binary_operation(), simplify_const_unary_operation(), simplify_const_vector_byte_offset(), simplify_const_vector_subreg(), simplify_context::simplify_merge_mask(), simplify_context::simplify_subreg(), simplify_context::simplify_ternary_operation(), simplify_context::simplify_unary_operation_1(), subreg_get_info(), type_for_widest_vector_mode(), validate_pattern(), vec_perm_indices_to_rtx(), vec_series_highpart_p(), vec_series_lowpart_p(), vect_create_epilog_for_reduction(), vect_grouped_load_supported(), and vect_grouped_store_supported().

◆ GET_MODE_PRECISION() [1/3]

template<typename T >
ALWAYS_INLINE if_poly< typenameT::measurement_type >::type GET_MODE_PRECISION ( const T & mode)

References mode_to_precision().

◆ GET_MODE_PRECISION() [2/3]

template<typename T >
ALWAYS_INLINE if_nonpoly< typenameT::measurement_type >::type GET_MODE_PRECISION ( const T & mode)

◆ GET_MODE_PRECISION() [3/3]

ALWAYS_INLINE poly_uint16 GET_MODE_PRECISION ( machine_mode mode)
Get the number of value bits of an object of mode MODE.   

References mode_to_precision().

Referenced by add_const_value_attribute(), add_mask_and_len_args(), adjust_mems(), avoid_type_punning_on_regs(), bitint_precision_kind(), build_common_tree_nodes(), build_truth_vector_type_for_mode(), can_atomic_load_p(), canonicalize_condition(), canonicalize_loop_ivs(), change_zero_ext(), clear_padding_bitint_needs_padding_p(), clear_padding_type(), clz_loc_descriptor(), combine_reaching_defs(), combine_simplify_rtx(), compute_record_mode(), convert_debug_memory_address(), convert_mode_scalar(), convert_modes(), convert_move(), convert_mult_to_widen(), convert_plusminus_to_widen(), convert_to_integer_1(), cse_insn(), cselib_record_sets(), default_scalar_mode_supported_p(), desired_pro_or_demotion_p(), do_compare_rtx_and_jump(), do_fixed_divide(), do_fixed_multiply(), do_fixed_shift(), do_store_flag(), do_tablejump(), doloop_modify(), doloop_optimize(), tree_switch_conversion::jump_table_cluster::emit(), emit_cstore(), expand_abs_nojump(), expand_absneg_bit(), expand_addsub_overflow(), expand_arith_overflow(), expand_arith_overflow_result_store(), expand_assignment(), expand_atomic_load(), expand_atomic_store(), expand_binop(), expand_builtin_signbit(), expand_clrsb_using_clz(), expand_compound_operation(), expand_copysign_absneg(), expand_copysign_bit(), expand_ctz(), expand_debug_expr(), expand_expr_real_1(), expand_expr_real_2(), expand_ffs(), expand_field_assignment(), expand_fix(), expand_float(), expand_fn_using_insn(), expand_mul_overflow(), expand_mult_const(), expand_one_cmpl_abs_nojump(), expand_shift_1(), expand_smod_pow2(), expand_ubsan_result_store(), expand_unop(), expand_vector_comparison(), expand_vector_condition(), extended_count(), extract_bit_field_1(), find_base_term(), find_base_value(), find_bitfield_repr_type(), find_split_point(), find_widening_optab_handler_and_mode(), finish_bitfield_representative(), fixed_convert_from_real(), fixed_from_string(), fixed_to_decimal(), flip_storage_order(), force_int_to_mode(), gen_extend_conv_libfunc(), gen_int_mode(), gen_trunc_conv_libfunc(), get_last_value(), get_mode_bounds(), wi::int_traits< rtx_mode_t >::get_precision(), gimple_fold_builtin_memset(), hwasan_truncate_to_tag_size(), HWI_COMPUTABLE_MODE_P(), if_then_else_cond(), immed_wide_int_const(), immed_wide_int_const_1(), init_expmed_one_conv(), init_num_sign_bit_copies_in_rep(), initialize_sizetypes(), instrument_bool_enum_load(), int_fits_type_p(), is_narrower_int_mode(), iv_number_of_iterations(), layout_type(), load_extend_op(), lsb_bitfield_op_p(), lto_input_mode_table(), lto_write_mode_table(), make_compound_operation_int(), make_extraction(), make_field_assignment(), mask_rtx(), wi::max_value(), wi::min_value(), mode_for_size(), mode_signbit_p(), native_decode_rtx(), native_decode_vector_rtx(), native_encode_int(), native_encode_rtx(), native_interpret_int(), bit_field_mode_iterator::next_mode(), nonzero_bits1(), num_sign_bit_copies1(), optimize_range_tests_diff(), optimize_range_tests_xor(), output_constant(), output_constant_pool_2(), paradoxical_subreg_p(), partial_subreg_p(), prefer_and_bit_test(), process_regs_for_copy(), real_convert_from_fixed(), record_dead_and_set_regs_1(), reduce_to_bit_field_precision(), reg_nonzero_bits_for_combine(), reg_num_sign_bit_copies_for_combine(), wi::shwi(), sign_extend_short_imm(), simplify_context::simplify_binary_operation_1(), simplify_compare_const(), simplify_comparison(), simplify_const_binary_operation(), simplify_const_relational_operation(), simplify_const_unary_operation(), simplify_const_vector_byte_offset(), simplify_const_vector_subreg(), simplify_using_ranges::simplify_float_conversion_using_ranges(), simplify_if_then_else(), simplify_operand_subreg(), simplify_context::simplify_relational_operation_1(), simplify_set(), simplify_shift_const_1(), simplify_context::simplify_subreg(), simplify_context::simplify_ternary_operation(), simplify_context::simplify_truncation(), simplify_context::simplify_unary_operation_1(), simplify_while_replacing(), smallest_mode_for_size(), split_reg(), store_bit_field_1(), store_constructor(), store_expr(), trunc_int_for_mode(), try_combine(), try_widen_shift_mode(), type_has_mode_precision_p(), update_rsp_from_reg_equal(), use_narrower_mode(), use_narrower_mode_test(), val_signbit_known_clear_p(), val_signbit_known_set_p(), val_signbit_p(), vect_create_epilog_for_reduction(), vect_recog_rotate_pattern(), vectorizable_reduction(), verify_gimple_assign_unary(), visit_reference_op_load(), widen_bswap(), and widen_leading().

◆ GET_MODE_SIZE() [1/3]

template<typename T >
ALWAYS_INLINE if_poly< typenameT::measurement_type >::type GET_MODE_SIZE ( const T & mode)

References mode_to_bytes().

◆ GET_MODE_SIZE() [2/3]

template<typename T >
ALWAYS_INLINE if_nonpoly< typenameT::measurement_type >::type GET_MODE_SIZE ( const T & mode)

◆ GET_MODE_SIZE() [3/3]

ALWAYS_INLINE poly_uint16 GET_MODE_SIZE ( machine_mode mode)
Get the size in bytes of an object of mode MODE.   

References mode_to_bytes().

Referenced by add_autoinc_candidates(), add_const_value_attribute(), add_pseudo_to_slot(), adjust_bit_field_mem_for_reg(), adjust_mems(), alignment_for_piecewise_move(), alter_reg(), anti_adjust_stack_and_probe_stack_clash(), apply_args_size(), apply_result_size(), tree_switch_conversion::switch_conversion::array_value_type(), asan_emit_stack_protection(), assemble_real(), assign_mem_slot(), assign_parm_find_stack_rtl(), assign_parm_remove_parallels(), assign_parm_setup_block(), assign_parm_setup_block_p(), assign_parm_setup_reg(), assign_parm_setup_stack(), assign_parms_unsplit_complex(), assign_stack_local_1(), assign_stack_slot_num_and_sort_pseudos(), autoinc_split(), avoid_constant_pool_reference(), build_def_use(), builtin_memset_gen_str(), builtin_memset_read_str(), by_pieces_ninsns(), c_readstr(), can_duplicate_and_interleave_p(), can_store_by_pieces(), can_vec_extract(), check_mem_read_rtx(), check_sibcall_argument_overlap_1(), choose_hard_reg_mode(), choose_reload_regs(), cleanup_auto_inc_dec(), clear_storage_hints(), coalesced_pseudo_reg_slot_compare(), combine_stack_adjustments_for_block(), complex_word_subreg_p(), concat_loc_descriptor(), concatn_loc_descriptor(), convert_descriptor_to_mode(), convert_memory_address_addr_space_1(), convert_mode_scalar(), convert_mult_to_widen(), convert_plusminus_to_widen(), convert_to_integer_1(), copy_blkmode_from_reg(), copy_blkmode_to_reg(), cse_insn(), cselib_hash_rtx(), cselib_lookup_1(), cselib_subst_to_values(), curr_insn_transform(), decompose(), default_class_max_nregs(), default_function_arg_padding(), default_hard_regno_nregs(), default_vectorize_related_mode(), df_word_lr_mark_ref(), discover_nonconstant_array_refs_r(), do_jump_by_parts_equality_rtx(), do_jump_by_parts_greater_rtx(), do_jump_by_parts_zero_rtx(), do_tablejump(), drop_writeback(), dwarf2out_frame_debug_cfa_offset(), dwarf2out_frame_debug_expr(), dwf_cfa_reg(), eliminate_regs_1(), elimination_effects(), emit_group_load_1(), emit_group_store(), emit_library_call_value_1(), emit_move_complex(), emit_move_complex_push(), emit_move_insn(), emit_move_multi_word(), emit_move_resolve_push(), emit_note_insn_var_location(), emit_push_insn(), emit_stack_save(), emit_store_flag_1(), emit_store_flag_int(), equiv_constant(), estimate_move_cost(), expand_absneg_bit(), expand_assignment(), expand_binop(), expand_builtin_apply(), expand_builtin_apply_args_1(), expand_builtin_issignaling(), expand_builtin_longjmp(), expand_builtin_nonlocal_goto(), expand_builtin_return(), expand_builtin_return_addr(), expand_builtin_setjmp_setup(), expand_builtin_signbit(), expand_builtin_strub_leave(), expand_builtin_update_setjmp_buf(), expand_call(), expand_clobber(), expand_compound_operation(), expand_copysign_absneg(), expand_copysign_bit(), expand_debug_expr(), expand_DIVMOD(), expand_expr_real_1(), expand_expr_real_2(), expand_function_start(), expand_ifn_atomic_compare_exchange_into_call(), expand_mult_highpart(), expand_shift_1(), expand_twoval_binop_libfunc(), expand_unop(), expand_value_return(), expand_vec_perm_var(), expression_expensive_p(), extract_bit_field_1(), extract_integral_bit_field(), extract_muldiv_1(), final_addr_vec_align(), find_args_size_adjust(), find_bitfield_repr_type(), find_dummy_reload(), find_inc_amount(), find_reloads(), find_reloads_subreg_address(), find_shift_sequence(), fold_read_from_constant_string(), for_each_inc_dec_find_inc_dec(), force_const_mem(), force_reload_address(), gen_highpart(), gen_lowpart_common(), gen_lowpart_for_combine(), gen_lowpart_general(), gen_memset_value_from_prev(), get_address_cost_ainc(), get_arg_pointer_save_area(), get_best_extraction_insn(), get_biv_step_1(), get_call_args(), get_len_load_store_mode(), get_nl_goto_field(), get_related_vectype_for_scalar_type(), get_reload_reg(), get_same_sized_vectype(), get_secondary_mem(), get_stored_val(), get_subreg_tracking_sizes(), op_by_pieces_d::get_usable_mode(), gimple_fold_builtin_memset(), strlen_pass::handle_builtin_memcmp(), hard_function_value(), init_emit_regs(), init_one_dwarf_reg_size(), init_return_column_size(), initialize_sizetypes(), inline_string_cmp(), insert_float(), interesting_mode_p(), ira_create_allocno_objects(), ira_reuse_stack_slot(), ira_sort_regnos_for_alter_reg(), iv_add(), layout_type(), load_register_parameters(), loc_descriptor(), loc_list_from_tree_1(), locate_and_pad_parm(), long_double_as_float128(), lower_oacc_reductions(), lra_constraint_offset(), lra_constraints(), lra_spill(), lra_update_biggest_mode(), lto_input_mode_table(), lto_write_mode_table(), make_compound_operation_int(), make_extraction(), mark_not_eliminable(), maybe_mode_change(), mem_loc_descriptor(), mergeable_string_section(), minmax_loc_descriptor(), multiple_reg_loc_descriptor(), narrowing_initializer_constant_valid_p(), native_decode_rtx(), native_encode_complex(), native_encode_fixed(), native_encode_int(), native_encode_real(), native_encode_rtx(), native_encode_vector_part(), native_interpret_complex(), native_interpret_expr(), native_interpret_fixed(), native_interpret_int(), native_interpret_real(), new_cselib_val(), nonoverlapping_memrefs_p(), notreg_cost(), offset_within_block_p(), offsettable_address_addr_space_p(), omp_clause_aligned_alignment(), operand_subword(), operands_match_p(), optimize_atomic_compare_exchange_p(), optimize_constant_pool(), output_constant(), output_constant_pool_2(), output_object_block(), pad_below(), pair_mem_strip_offset(), place_block_symbol(), precompute_register_parameters(), prepare_call_arguments(), process_addr_reg(), process_alt_operands(), function_arg_info::promoted_size_in_bytes(), pseudo_reg_slot_compare(), push_operand(), vn_walk_cb_data::push_partial_def(), push_reload(), qimode_for_vec_perm(), read_complex_part(), read_modify_subreg_p(), recompute_pool_offsets(), record_operand_costs(), record_store(), record_subregs_of_mode(), remove_invalid_subreg_refs(), resolve_shift_zext(), resolve_simple_move(), result_vector(), rotate_loc_descriptor(), rtl_for_decl_init(), rtl_for_decl_location(), rtx_addr_can_trap_p_1(), rtx_cost(), op_by_pieces_d::run(), scompare_loc_descriptor(), scompare_loc_descriptor_narrow(), setup_save_areas(), shorten_branches(), simd_clone_init_simd_arrays(), simplify_context::simplify_binary_operation_1(), simplify_compare_const(), simplify_comparison(), simplify_gen_subreg_concatn(), simplify_context::simplify_gen_vec_select(), simplify_immed_subreg(), simplify_operand_subreg(), simplify_context::simplify_relational_operation_1(), simplify_set(), simplify_shift_const_1(), simplify_context::simplify_subreg(), simplify_context::simplify_truncation(), simplify_vector_constructor(), simplify_while_replacing(), sjlj_emit_dispatch_table(), op_by_pieces_d::smallest_fixed_size_mode_for_size(), store_bit_field_1(), store_bit_field_using_insv(), store_constructor(), store_integral_bit_field(), store_one_arg(), store_split_bit_field(), string_cst_read_str(), subreg_get_info(), subreg_highpart_offset(), subreg_lowpart_offset(), subreg_lsb_1(), subreg_offset_from_lsb(), pair_fusion_bb_info::track_access(), pair_fusion_bb_info::track_via_mem_expr(), true_dependence_1(), try_merge(), pair_fusion::try_promote_writeback(), function_arg_info::type_size_in_bytes(), ubsan_encode_value(), ucompare_loc_descriptor(), undefined_operand_subword_p(), undistribute_bitref_for_vector(), valid_multiword_target_p(), validate_subreg(), vect_build_slp_tree_2(), vect_enhance_data_refs_alignment(), vect_slp_region(), vect_supportable_dr_alignment(), vect_transform_loops(), vector_alignment_reachable_p(), vectorizable_assignment(), vectorizable_conversion(), vectorizable_load(), vectorizable_operation(), vectorizable_reduction(), vectorizable_simd_clone_call(), verify_gimple_assign_binary(), verify_gimple_assign_ternary(), verify_gimple_assign_unary(), vn_reference_lookup_3(), widen_memory_access(), widen_operand(), widest_fixed_size_mode_for_size(), word_dce_process_block(), write_complex_part(), and write_dependence_p().

◆ GET_MODE_WIDER_MODE()

template<typename T >
ALWAYS_INLINE opt_mode< T > GET_MODE_WIDER_MODE ( const T & m)
Get the next wider mode (eg, QI -> HI -> SI -> DI -> TI
or { HF, BF } -> SF -> DF -> XF -> TF).
This is similar to GET_MODE_NEXT_MODE, but while GET_MODE_NEXT_MODE
can include mode that have the same precision (e.g.
GET_MODE_NEXT_MODE (HFmode) can be BFmode even when both have the same
precision), this one will skip those.  And always VOIDmode for
modes whose class is !CLASS_HAS_WIDER_MODES_P.   

References mode_wider.

Referenced by tree_switch_conversion::switch_conversion::array_value_type(), can_compare_p(), can_mult_highpart_p(), convert_mult_to_widen(), convert_plusminus_to_widen(), emit_note_insn_var_location(), expand_binop(), expmed_mult_highpart(), expmed_mult_highpart_optab(), extract_high_half(), find_widening_optab_handler_and_mode(), mode_iterator::get_known_wider(), mode_iterator::get_wider(), mode_iterator::get_wider(), init_expmed_one_mode(), init_num_sign_bit_copies_in_rep(), lto_input_mode_table(), make_extraction(), bit_field_mode_iterator::next_mode(), and simplify_using_ranges::simplify_float_conversion_using_ranges().

◆ get_narrowest_mode()

template<typename T >
T get_narrowest_mode ( T mode)
inline
Return the narrowest mode in T's class.   

References class_narrowest_mode, and GET_MODE_CLASS.

Referenced by tree_switch_conversion::switch_conversion::array_value_type().

◆ gt_ggc_mx()

template<typename T >
void gt_ggc_mx ( pod_mode< T > * )

◆ gt_pch_nx() [1/2]

template<typename T >
void gt_pch_nx ( pod_mode< T > * )

◆ gt_pch_nx() [2/2]

template<typename T >
void gt_pch_nx ( pod_mode< T > * ,
gt_pointer_operator ,
void *  )

◆ HWI_COMPUTABLE_MODE_P() [1/2]

◆ HWI_COMPUTABLE_MODE_P() [2/2]

bool HWI_COMPUTABLE_MODE_P ( scalar_int_mode mode)
inline

◆ init_adjust_machine_modes()

void init_adjust_machine_modes ( void )
extern
Target-dependent machine mode initialization - in insn-modes.cc.   

Referenced by do_compile().

◆ int_mode_for_mode()

◆ int_mode_for_size()

opt_scalar_int_mode int_mode_for_size ( poly_uint64 size,
int limit )
inline
Return the machine mode to use for a MODE_INT of SIZE bits, if one
exists.  If LIMIT is nonzero, modes wider than MAX_FIXED_MODE_SIZE
will not be used.   

References dyn_cast(), and mode_for_size().

Referenced by alignment_for_piecewise_move(), alter_reg(), assign_parm_setup_block(), can_duplicate_and_interleave_p(), can_vec_extract(), combine_instructions(), compute_argument_addresses(), convert_mode_scalar(), copy_blkmode_from_reg(), do_jump(), emit_block_cmp_via_loop(), emit_block_move_via_loop(), emit_block_move_via_oriented_loop(), emit_library_call_value_1(), expand_builtin_atomic_clear(), expand_builtin_atomic_test_and_set(), expand_builtin_issignaling(), expand_builtin_powi(), expand_DEFERRED_INIT(), expand_expr_real_1(), expand_field_assignment(), expand_ifn_atomic_compare_exchange(), expand_mul_overflow(), expand_vector_parallel(), flip_storage_order(), fold_builtin_atomic_always_lock_free(), gen_int_shift_amount(), gen_lowpart_common(), get_builtin_sync_mode(), gimple_fold_builtin_memory_op(), strlen_pass::handle_builtin_memcmp(), init_optabs(), int_mode_for_mode(), is_widening_mult_rhs_p(), layout_type(), make_extraction(), mem_loc_descriptor(), mode_for_vector(), output_constant_pool_2(), set_builtin_user_assembler_name(), simple_move(), simplify_comparison(), simplify_shift_const_1(), simplify_context::simplify_subreg(), simplify_context::simplify_unary_operation_1(), store_one_arg(), vect_lanes_optab_supported_p(), vector_type_mode(), vector_vector_composition_type(), vectorizable_conversion(), and vectorizable_store().

◆ is_a() [1/3]

template<typename T , typename U >
bool is_a ( const opt_mode< U > & m)
inline

◆ is_a() [2/3]

template<typename T >
bool is_a ( machine_mode m)
inline
Return true if mode M has type T.   

Referenced by is_narrower_int_mode().

◆ is_a() [3/3]

template<typename T , typename U >
bool is_a ( machine_mode m,
U * result )
inline
Return true if mode M has type T, storing it as a T in *RESULT
if so.   

References T.

◆ is_complex_float_mode()

template<typename T >
bool is_complex_float_mode ( machine_mode mode,
T * cmode )
inline
Return true if MODE has class MODE_COMPLEX_FLOAT, storing it as
a complex_mode in *CMODE if so.   

References GET_MODE_CLASS.

◆ is_complex_int_mode()

template<typename T >
bool is_complex_int_mode ( machine_mode mode,
T * cmode )
inline
Return true if MODE has class MODE_COMPLEX_INT, storing it as
a complex_mode in *CMODE if so.   

References GET_MODE_CLASS.

Referenced by expand_function_end().

◆ is_float_mode()

template<typename T >
bool is_float_mode ( machine_mode mode,
T * float_mode )
inline
Return true if MODE has class MODE_FLOAT, storing it as a
scalar_float_mode in *FLOAT_MODE if so.   

References GET_MODE_CLASS.

Referenced by expand_omp_atomic(), and get_related_vectype_for_scalar_type().

◆ is_int_mode()

◆ is_narrower_int_mode()

bool is_narrower_int_mode ( machine_mode mode,
scalar_int_mode limit )
inline
Return true if MODE is a scalar integer mode with a precision
smaller than LIMIT's precision.   

References GET_MODE_PRECISION(), and is_a().

Referenced by expand_fix(), expand_float(), and rotate_loc_descriptor().

◆ mode_for_size()

opt_machine_mode mode_for_size ( poly_uint64 size,
enum mode_class mclass,
int limit )
extern

◆ mode_for_vector()

opt_machine_mode mode_for_vector ( scalar_mode innermode,
poly_uint64 nunits )
extern
Find a mode that is suitable for representing a vector with NUNITS
elements of mode INNERMODE, if one exists.  The returned mode can be
either an integer mode or a vector mode.   

References FOR_EACH_MODE_FROM, GET_MODE_BITSIZE(), GET_MODE_CLASS, GET_MODE_INNER, GET_MODE_NUNITS(), have_regs_of_mode, int_mode_for_size(), known_eq, SCALAR_ACCUM_MODE_P, SCALAR_FLOAT_MODE_P, SCALAR_FRACT_MODE_P, SCALAR_UACCUM_MODE_P, SCALAR_UFRACT_MODE_P, and targetm.

Referenced by default_vectorize_related_mode(), get_related_vectype_for_scalar_type(), layout_type(), simplify_vector_constructor(), and undistribute_bitref_for_vector().

◆ mode_to_bits()

ALWAYS_INLINE poly_uint16 mode_to_bits ( machine_mode mode)
Return the base GET_MODE_BITSIZE value for MODE.   

References mode_to_bytes().

Referenced by GET_MODE_BITSIZE(), and GET_MODE_BITSIZE().

◆ mode_to_bytes()

ALWAYS_INLINE poly_uint16 mode_to_bytes ( machine_mode mode)
Return the base GET_MODE_SIZE value for MODE.   

References mode_size.

Referenced by GET_MODE_SIZE(), GET_MODE_SIZE(), fixed_size_mode::includes_p(), and mode_to_bits().

◆ mode_to_inner()

ALWAYS_INLINE scalar_mode mode_to_inner ( machine_mode mode)
Return the base GET_MODE_INNER value for MODE.   

References mode_inner.

◆ mode_to_nunits()

ALWAYS_INLINE poly_uint16 mode_to_nunits ( machine_mode mode)
Return the base GET_MODE_NUNITS value for MODE.   

References mode_nunits.

Referenced by GET_MODE_NUNITS(), and GET_MODE_NUNITS().

◆ mode_to_precision()

ALWAYS_INLINE poly_uint16 mode_to_precision ( machine_mode mode)
Return the base GET_MODE_PRECISION value for MODE.   

References mode_precision.

Referenced by GET_MODE_PRECISION(), GET_MODE_PRECISION(), and HWI_COMPUTABLE_MODE_P().

◆ mode_to_unit_precision()

ALWAYS_INLINE unsigned short mode_to_unit_precision ( machine_mode mode)
Return the base GET_MODE_UNIT_PRECISION value for MODE.   

References mode_unit_precision.

◆ mode_to_unit_size()

ALWAYS_INLINE unsigned char mode_to_unit_size ( machine_mode mode)
Return the base GET_MODE_UNIT_SIZE value for MODE.   

References mode_unit_size.

◆ related_int_vector_mode()

opt_machine_mode related_int_vector_mode ( machine_mode vector_mode)
extern
If a piece of code is using vector mode VECTOR_MODE and also wants
to operate on integer vectors with the same element size and number
of elements, return the vector mode it should use.  Return an empty
opt_machine_mode if there is no supported vector mode with the
required properties.

Unlike mode_for_vector. any returned mode is guaranteed to satisfy
both VECTOR_MODE_P and targetm.vector_mode_supported_p.   

References gcc_assert, GET_MODE_INNER, GET_MODE_NUNITS(), int_mode_for_mode(), related_vector_mode(), and VECTOR_MODE_P.

Referenced by default_get_mask_mode(), expand_vec_perm_1(), expand_vec_perm_const(), and signed_or_unsigned_type_for().

◆ related_vector_mode()

opt_machine_mode related_vector_mode ( machine_mode vector_mode,
scalar_mode element_mode,
poly_uint64 nunits )
extern
If a piece of code is using vector mode VECTOR_MODE and also wants
to operate on elements of mode ELEMENT_MODE, return the vector mode
it should use for those elements.  If NUNITS is nonzero, ensure that
the mode has exactly NUNITS elements, otherwise pick whichever vector
size pairs the most naturally with VECTOR_MODE; this may mean choosing
a mode with a different size and/or number of elements, depending on
what the target prefers.  Return an empty opt_machine_mode if there
is no supported vector mode with the required properties.

Unlike mode_for_vector. any returned mode is guaranteed to satisfy
both VECTOR_MODE_P and targetm.vector_mode_supported_p.   

References element_mode(), gcc_assert, targetm, and VECTOR_MODE_P.

Referenced by can_vec_extract(), can_vec_mask_load_store_p(), extract_bit_field_1(), get_len_load_store_mode(), get_related_vectype_for_scalar_type(), omp_clause_aligned_alignment(), qimode_for_vec_perm(), related_int_vector_mode(), vect_analyze_loop_1(), vect_chooses_same_modes_p(), vect_slp_region(), vector_vector_composition_type(), vectorizable_store(), and vectorized_internal_fn_supported_p().

◆ smallest_int_mode_for_size()

◆ smallest_mode_for_size()

machine_mode smallest_mode_for_size ( poly_uint64 size,
enum mode_class mclass )
extern
Return the narrowest mode of class MCLASS that contains at least
SIZE bits.  Abort if no such mode exists.   

References FOR_EACH_MODE_IN_CLASS, gcc_assert, GET_MODE_PRECISION(), i, int_n_data, int_n_enabled_p, known_ge, known_lt, and int_n_data_t::m.

Referenced by smallest_int_mode_for_size().

Variable Documentation

◆ byte_mode

scalar_int_mode byte_mode
extern
Define the integer modes whose sizes are BITS_PER_UNIT and BITS_PER_WORD
and the mode whose class is Pmode and whose size is POINTER_SIZE.   
Commonly used modes.   

Referenced by get_traditional_extraction_insn(), init_derived_machine_modes(), and set_storage_via_setmem().

◆ class_narrowest_mode

const unsigned short class_narrowest_mode[MAX_MODE_CLASS]
extern
For each class, get the narrowest mode in that class.   

Referenced by get_narrowest_mode().

◆ int_n_data

◆ int_n_enabled_p

bool int_n_enabled_p[NUM_INT_N_ENTS]
extern
This is also in tree.h.  genmodes.cc guarantees the're sorted from
smallest bitsize to largest bitsize.  

Referenced by do_compile(), find_bitfield_repr_type(), gimple_signed_or_unsigned_type(), initialize_sizetypes(), lhd_type_for_size(), mode_for_size(), and smallest_mode_for_size().

◆ mode_2xwider

const unsigned short mode_2xwider[NUM_MACHINE_MODES]
extern

Referenced by GET_MODE_2XWIDER_MODE().

◆ mode_base_align

CONST_MODE_BASE_ALIGN unsigned short mode_base_align[NUM_MACHINE_MODES]
extern
Determine alignment, 1<=result<=BIGGEST_ALIGNMENT.   

Referenced by get_mode_alignment().

◆ mode_class

const unsigned char mode_class[NUM_MACHINE_MODES]
extern
Get the general kind of object that mode MODE represents
(integer, floating, complex, etc.)   

◆ mode_complex

const unsigned short mode_complex[NUM_MACHINE_MODES]
extern
Get the complex mode from the component mode.   

◆ mode_fbit

CONST_MODE_FBIT unsigned char mode_fbit[NUM_MACHINE_MODES]
extern
Get the number of fractional bits of an object of mode MODE.   

◆ mode_ibit

CONST_MODE_IBIT unsigned char mode_ibit[NUM_MACHINE_MODES]
extern
Get the number of integral bits of an object of mode MODE.   

◆ mode_inner

const unsigned short mode_inner[NUM_MACHINE_MODES]
extern

Referenced by mode_to_inner().

◆ mode_mask_array

CONST_MODE_MASK unsigned HOST_WIDE_INT mode_mask_array[NUM_MACHINE_MODES]
extern
Get a bitmask containing 1 for all bits in a word
that fit within mode MODE.   

◆ mode_name

const char* const mode_name[NUM_MACHINE_MODES]
extern

◆ mode_next

const unsigned short mode_next[NUM_MACHINE_MODES]
extern

Referenced by GET_MODE_NEXT_MODE().

◆ mode_nunits

CONST_MODE_NUNITS poly_uint16 mode_nunits[NUM_MACHINE_MODES]
extern

Referenced by mode_to_nunits().

◆ mode_precision

CONST_MODE_PRECISION poly_uint16 mode_precision[NUM_MACHINE_MODES]
extern

Referenced by mode_to_precision().

◆ mode_size

CONST_MODE_SIZE poly_uint16 mode_size[NUM_MACHINE_MODES]
extern

◆ mode_unit_precision

const unsigned short mode_unit_precision[NUM_MACHINE_MODES]
extern

Referenced by mode_to_unit_precision().

◆ mode_unit_size

CONST_MODE_UNIT_SIZE unsigned char mode_unit_size[NUM_MACHINE_MODES]
extern

Referenced by mode_to_unit_size().

◆ mode_wider

const unsigned short mode_wider[NUM_MACHINE_MODES]
extern

Referenced by GET_MODE_WIDER_MODE().

◆ ptr_mode

scalar_int_mode ptr_mode
extern

Referenced by asan_emit_allocas_unpoison(), asan_emit_stack_protection(), default_addr_space_pointer_mode(), default_emit_call_builtin___clear_cache(), default_valid_pointer_mode(), emit_block_op_via_libcall(), expand_asan_emit_allocas_unpoison(), expand_atomic_compare_and_swap(), expand_atomic_fetch_op(), expand_BITINTTOFLOAT(), expand_builtin_adjust_descriptor(), expand_builtin_alloca(), expand_builtin_apply(), expand_builtin_eh_copy_values(), expand_builtin_eh_pointer(), expand_builtin_extend_pointer(), expand_builtin_frob_return_addr(), expand_builtin_init_descriptor(), expand_builtin_memory_copy_args(), expand_builtin_memset_args(), expand_builtin_next_arg(), expand_builtin_sincos(), expand_builtin_stack_address(), expand_builtin_strncpy(), expand_builtin_strub_enter(), expand_builtin_strub_leave(), expand_builtin_strub_update(), expand_DIVMODBITINT(), expand_dw2_landing_pad_for_region(), expand_expr_addr_expr(), expand_expr_real_2(), expand_FLOATTOBITINT(), expand_HWASAN_ALLOCA_UNPOISON(), expand_HWASAN_MARK(), expand_HWASAN_SET_TAG(), expand_MULBITINT(), expand_omp_atomic_mutex(), expand_omp_atomic_pipeline(), fold_builtin_memcmp(), get_memory_rtx(), get_nl_goto_field(), get_section_anchor(), gimple_fold_builtin_memory_op(), gimple_load_first_char(), strlen_pass::handle_builtin_memcmp(), hwasan_emit_prologue(), hwasan_emit_untag_frame(), init_derived_machine_modes(), maybe_emit_call_builtin___clear_cache(), maybe_emit_sync_lock_test_and_set(), mem_loc_descriptor(), nonzero_bits1(), num_sign_bit_copies1(), prepare_call_address(), process_addr_reg(), push_block(), set_stack_check_libfunc(), simplify_context::simplify_unary_operation_1(), sjlj_emit_dispatch_table(), sjlj_emit_function_enter(), stack_protect_epilogue(), try_store_by_multiple_pieces(), and verify_gimple_assign_unary().

◆ word_mode

scalar_int_mode word_mode
extern

Referenced by adjust_bit_field_mem_for_reg(), anti_adjust_stack_and_probe_stack_clash(), assign_parm_setup_block(), build_word_mode_vector_type(), can_assign_to_reg_without_clobbers_p(), can_decompose_p(), compute_costs(), compute_splitting_shift(), convert_mode_scalar(), copy_blkmode_from_reg(), copy_blkmode_to_reg(), create_new_invariant(), decompose_register(), default_emutls_var_fields(), default_libgcc_cmp_return_mode(), default_libgcc_shift_count_mode(), default_preferred_simd_mode(), default_unwind_word_mode(), desired_pro_or_demotion_p(), do_jump_by_parts_equality_rtx(), do_jump_by_parts_greater_rtx(), do_jump_by_parts_zero_rtx(), do_output_reload(), doloop_optimize(), tree_switch_conversion::bit_test_cluster::emit(), emit_block_cmp_via_loop(), emit_block_move_via_loop(), emit_library_call_value_1(), emit_push_insn(), emit_stack_probe(), emit_store_flag_1(), emit_store_flag_force(), emit_store_flag_int(), emutls_common_1(), equiv_constant(), expand_absneg_bit(), expand_binop(), expand_builtin_signbit(), expand_copysign_absneg(), expand_copysign_bit(), expand_debug_expr(), expand_DIVMOD(), expand_doubleword_bswap(), expand_doubleword_clz_ctz_ffs(), expand_doubleword_mod(), expand_doubleword_mult(), expand_doubleword_parity(), expand_doubleword_popcount(), expand_doubleword_shift(), expand_doubleword_shift_condmove(), expand_expr_real_2(), expand_SET_EDOM(), expand_subword_shift(), expand_superword_shift(), expand_unop(), expand_vector_parallel(), expression_expensive_p(), extract_high_half(), extract_integral_bit_field(), extract_split_bit_field(), find_decomposable_shift_zext(), find_decomposable_subregs(), find_if_header(), find_reloads_address_1(), force_const_mem(), get_optab_extraction_insn(), get_traditional_extraction_insn(), strlen_pass::handle_builtin_memcmp(), init_caller_save(), init_derived_machine_modes(), init_expr_target(), init_lower_subreg(), init_reg_modes_target(), load_register_parameters(), lshift_cheap_p(), make_extraction(), mem_loc_descriptor(), move_block_from_reg(), move_block_to_reg(), operand_subword(), optimize_range_tests_to_bit_test(), push_reload(), reload_cse_regs_1(), reload_cse_simplify_operands(), reload_cse_simplify_set(), replace_read(), resolve_clobber(), resolve_shift_zext(), resolve_simple_move(), setup_prohibited_mode_move_regs(), simplify_and_const_int_1(), simplify_context::simplify_binary_operation_1(), simplify_const_binary_operation(), simplify_context::simplify_subreg(), simplify_while_replacing(), store_constructor(), store_integral_bit_field(), store_split_bit_field(), store_unaligned_arguments_into_pseudos(), try_combine(), valid_multiword_target_p(), validate_subreg(), and vectorizable_operation().