GCC Middle and Back End API Reference
Macros | Functions | Variables
internal-fn.cc File Reference
#include "config.h"
#include "system.h"
#include "coretypes.h"
#include "backend.h"
#include "target.h"
#include "rtl.h"
#include "tree.h"
#include "gimple.h"
#include "predict.h"
#include "stringpool.h"
#include "tree-vrp.h"
#include "tree-ssanames.h"
#include "expmed.h"
#include "memmodel.h"
#include "optabs.h"
#include "emit-rtl.h"
#include "diagnostic-core.h"
#include "fold-const.h"
#include "internal-fn.h"
#include "stor-layout.h"
#include "dojump.h"
#include "expr.h"
#include "attribs.h"
#include "asan.h"
#include "ubsan.h"
#include "recog.h"
#include "builtins.h"
#include "optabs-tree.h"
#include "gimple-ssa.h"
#include "tree-phinodes.h"
#include "ssa-iterators.h"
#include "explow.h"
#include "rtl-iter.h"
#include "gimple-range.h"
#include "fold-const-call.h"
#include "tree-ssa-live.h"
#include "tree-outof-ssa.h"
#include "langhooks.h"
#include "internal-fn.def"
Include dependency graph for internal-fn.cc:

Macros

#define DEF_INTERNAL_FN(CODE, FLAGS, FNSPEC)
 
#define DEF_INTERNAL_OPTAB_FN(NAME, FLAGS, OPTAB, TYPE)
 
#define DEF_INTERNAL_SIGNED_OPTAB_FN(NAME, FLAGS, SELECTOR, SIGNED_OPTAB, UNSIGNED_OPTAB, TYPE)
 
#define DEF_INTERNAL_FLT_FN(NAME, FLAGS, OPTAB, TYPE)
 
#define DEF_INTERNAL_FLT_FLOATN_FN(NAME, FLAGS, OPTAB, TYPE)
 
#define DEF_INTERNAL_INT_FN(NAME, FLAGS, OPTAB, TYPE)
 
#define DEF_INTERNAL_INT_EXT_FN(NAME, FLAGS, OPTAB, TYPE)
 
#define DEF_INTERNAL_WIDENING_OPTAB_FN(NAME, FLAGS, SELECTOR, SOPTAB, UOPTAB, TYPE)
 
#define DEF_INTERNAL_COND_FN(NAME, FLAGS, OPTAB, TYPE)
 
#define DEF_INTERNAL_SIGNED_COND_FN(NAME, FLAGS, SELECTOR, SIGNED_OPTAB, UNSIGNED_OPTAB, TYPE)
 
#define DEF_INTERNAL_FN(CODE, FLAGS, FNSPEC)
 
#define DEF_INTERNAL_OPTAB_FN(NAME, FLAGS, OPTAB, TYPE)
 
#define DEF_INTERNAL_SIGNED_OPTAB_FN(NAME, FLAGS, SELECTOR, SIGNED_OPTAB, UNSIGNED_OPTAB, TYPE)
 
#define DEF_INTERNAL_FLT_FN(NAME, FLAGS, OPTAB, TYPE)
 
#define DEF_INTERNAL_FLT_FLOATN_FN(NAME, FLAGS, OPTAB, TYPE)
 
#define DEF_INTERNAL_INT_FN(NAME, FLAGS, OPTAB, TYPE)
 
#define DEF_INTERNAL_INT_EXT_FN(NAME, FLAGS, OPTAB, TYPE)
 
#define DEF_INTERNAL_WIDENING_OPTAB_FN(NAME, FLAGS, SELECTOR, SOPTAB, UOPTAB, TYPE)
 
#define DEF_INTERNAL_COND_FN(NAME, FLAGS, OPTAB, TYPE)
 
#define DEF_INTERNAL_SIGNED_COND_FN(NAME, FLAGS, SELECTOR, SIGNED_OPTAB, UNSIGNED_OPTAB, TYPE)
 
#define DEF_INTERNAL_FN(NAME, FLAGS, TYPE)
 
#define DEF_INTERNAL_WIDENING_OPTAB_FN(NAME, F, S, SO, UO, T)
 
#define DEF_INTERNAL_OPTAB_FN(NAME, FLAGS, OPTAB, TYPE)
 
#define DEF_INTERNAL_SIGNED_OPTAB_FN(NAME, FLAGS, SELECTOR, SIGNED_OPTAB, UNSIGNED_OPTAB, TYPE)
 
#define DEF_INTERNAL_FLT_FN(NAME, FLAGS, OPTAB, TYPE)
 
#define DEF_INTERNAL_FLT_FLOATN_FN(NAME, FLAGS, OPTAB, TYPE)
 
#define DEF_INTERNAL_INT_FN(NAME, FLAGS, OPTAB, TYPE)
 
#define DEF_INTERNAL_INT_EXT_FN(NAME, FLAGS, OPTAB, TYPE)
 
#define DEF_INTERNAL_COND_FN(NAME, FLAGS, OPTAB, TYPE)
 
#define DEF_INTERNAL_SIGNED_COND_FN(NAME, FLAGS, SELECTOR, SIGNED_OPTAB, UNSIGNED_OPTAB, TYPE)
 
#define DEF_INTERNAL_FN(NAME, FLAGS, TYPE)
 
#define DEF_INTERNAL_WIDENING_OPTAB_FN(NAME, F, S, SO, UO, T)
 
#define DEF_INTERNAL_OPTAB_FN(NAME, FLAGS, OPTAB, TYPE)
 
#define DEF_INTERNAL_SIGNED_OPTAB_FN(NAME, FLAGS, SELECTOR, SIGNED_OPTAB, UNSIGNED_OPTAB, TYPE)
 
#define DEF_INTERNAL_FLT_FN(NAME, FLAGS, OPTAB, TYPE)
 
#define DEF_INTERNAL_FLT_FLOATN_FN(NAME, FLAGS, OPTAB, TYPE)
 
#define DEF_INTERNAL_INT_FN(NAME, FLAGS, OPTAB, TYPE)
 
#define DEF_INTERNAL_INT_EXT_FN(NAME, FLAGS, OPTAB, TYPE)
 
#define DEF_INTERNAL_COND_FN(NAME, FLAGS, OPTAB, TYPE)
 
#define DEF_INTERNAL_SIGNED_COND_FN(NAME, FLAGS, SELECTOR, SIGNED_OPTAB, UNSIGNED_OPTAB, TYPE)
 
#define DEF_INTERNAL_FN(CODE, FLAGS, FNSPEC)
 
#define DEF_INTERNAL_OPTAB_FN(NAME, FLAGS, OPTAB, TYPE)
 
#define DEF_INTERNAL_SIGNED_OPTAB_FN(NAME, FLAGS, SELECTOR, SIGNED_OPTAB, UNSIGNED_OPTAB, TYPE)
 
#define DEF_INTERNAL_FLT_FN(NAME, FLAGS, OPTAB, TYPE)
 
#define DEF_INTERNAL_FLT_FLOATN_FN(NAME, FLAGS, OPTAB, TYPE)
 
#define DEF_INTERNAL_INT_FN(NAME, FLAGS, OPTAB, TYPE)
 
#define DEF_INTERNAL_INT_EXT_FN(NAME, FLAGS, OPTAB, TYPE)
 
#define DEF_INTERNAL_WIDENING_OPTAB_FN(NAME, FLAGS, SELECTOR, SOPTAB, UOPTAB, TYPE)
 
#define DEF_INTERNAL_COND_FN(NAME, FLAGS, OPTAB, TYPE)
 
#define DEF_INTERNAL_SIGNED_COND_FN(NAME, FLAGS, SELECTOR, SIGNED_OPTAB, UNSIGNED_OPTAB, TYPE)
 
#define not_direct   { -2, -2, false }
 
#define mask_load_direct   { -1, 2, false }
 
#define load_lanes_direct   { -1, -1, false }
 
#define mask_load_lanes_direct   { -1, -1, false }
 
#define gather_load_direct   { 3, 1, false }
 
#define len_load_direct   { -1, -1, false }
 
#define mask_len_load_direct   { -1, 4, false }
 
#define mask_store_direct   { 3, 2, false }
 
#define store_lanes_direct   { 0, 0, false }
 
#define mask_store_lanes_direct   { 0, 0, false }
 
#define vec_cond_mask_direct   { 1, 0, false }
 
#define vec_cond_mask_len_direct   { 1, 1, false }
 
#define vec_cond_direct   { 2, 0, false }
 
#define scatter_store_direct   { 3, 1, false }
 
#define len_store_direct   { 3, 3, false }
 
#define mask_len_store_direct   { 4, 5, false }
 
#define vec_set_direct   { 3, 3, false }
 
#define vec_extract_direct   { 0, -1, false }
 
#define unary_direct   { 0, 0, true }
 
#define unary_convert_direct   { -1, 0, true }
 
#define binary_direct   { 0, 0, true }
 
#define ternary_direct   { 0, 0, true }
 
#define cond_unary_direct   { 1, 1, true }
 
#define cond_binary_direct   { 1, 1, true }
 
#define cond_ternary_direct   { 1, 1, true }
 
#define cond_len_unary_direct   { 1, 1, true }
 
#define cond_len_binary_direct   { 1, 1, true }
 
#define cond_len_ternary_direct   { 1, 1, true }
 
#define while_direct   { 0, 2, false }
 
#define fold_extract_direct   { 2, 2, false }
 
#define fold_len_extract_direct   { 2, 2, false }
 
#define fold_left_direct   { 1, 1, false }
 
#define mask_fold_left_direct   { 1, 1, false }
 
#define mask_len_fold_left_direct   { 1, 1, false }
 
#define check_ptrs_direct   { 0, 0, false }
 
#define DEF_INTERNAL_FN(CODE, FLAGS, FNSPEC)
 
#define DEF_INTERNAL_OPTAB_FN(CODE, FLAGS, OPTAB, TYPE)
 
#define DEF_INTERNAL_SIGNED_OPTAB_FN(CODE, FLAGS, SELECTOR, SIGNED_OPTAB, UNSIGNED_OPTAB, TYPE)
 
#define DEF_INTERNAL_FLT_FN(NAME, FLAGS, OPTAB, TYPE)
 
#define DEF_INTERNAL_FLT_FLOATN_FN(NAME, FLAGS, OPTAB, TYPE)
 
#define DEF_INTERNAL_INT_FN(NAME, FLAGS, OPTAB, TYPE)
 
#define DEF_INTERNAL_INT_EXT_FN(NAME, FLAGS, OPTAB, TYPE)
 
#define DEF_INTERNAL_WIDENING_OPTAB_FN(NAME, FLAGS, SELECTOR, SOPTAB, UOPTAB, TYPE)
 
#define DEF_INTERNAL_COND_FN(NAME, FLAGS, OPTAB, TYPE)
 
#define DEF_INTERNAL_SIGNED_COND_FN(NAME, FLAGS, SELECTOR, SIGNED_OPTAB, UNSIGNED_OPTAB, TYPE)
 
#define expand_mask_load_optab_fn   expand_partial_load_optab_fn
 
#define expand_mask_load_lanes_optab_fn   expand_mask_load_optab_fn
 
#define expand_len_load_optab_fn   expand_partial_load_optab_fn
 
#define expand_mask_len_load_optab_fn   expand_partial_load_optab_fn
 
#define expand_mask_store_optab_fn   expand_partial_store_optab_fn
 
#define expand_mask_store_lanes_optab_fn   expand_mask_store_optab_fn
 
#define expand_len_store_optab_fn   expand_partial_store_optab_fn
 
#define expand_mask_len_store_optab_fn   expand_partial_store_optab_fn
 
#define INIT_PATTERN_VALUE   0xFE
 
#define expand_unary_optab_fn(FN, STMT, OPTAB)
 
#define expand_binary_optab_fn(FN, STMT, OPTAB)
 
#define expand_ternary_optab_fn(FN, STMT, OPTAB)
 
#define expand_cond_unary_optab_fn(FN, STMT, OPTAB)
 
#define expand_cond_binary_optab_fn(FN, STMT, OPTAB)
 
#define expand_cond_ternary_optab_fn(FN, STMT, OPTAB)
 
#define expand_cond_len_unary_optab_fn(FN, STMT, OPTAB)
 
#define expand_cond_len_binary_optab_fn(FN, STMT, OPTAB)
 
#define expand_cond_len_ternary_optab_fn(FN, STMT, OPTAB)
 
#define expand_fold_extract_optab_fn(FN, STMT, OPTAB)
 
#define expand_fold_len_extract_optab_fn(FN, STMT, OPTAB)
 
#define expand_fold_left_optab_fn(FN, STMT, OPTAB)
 
#define expand_mask_fold_left_optab_fn(FN, STMT, OPTAB)
 
#define expand_mask_len_fold_left_optab_fn(FN, STMT, OPTAB)
 
#define expand_check_ptrs_optab_fn(FN, STMT, OPTAB)
 
#define expand_unary_convert_optab_fn(FN, STMT, OPTAB)
 
#define expand_vec_extract_optab_fn(FN, STMT, OPTAB)
 
#define direct_unary_optab_supported_p   direct_optab_supported_p
 
#define direct_unary_convert_optab_supported_p   convert_optab_supported_p
 
#define direct_binary_optab_supported_p   direct_optab_supported_p
 
#define direct_ternary_optab_supported_p   direct_optab_supported_p
 
#define direct_cond_unary_optab_supported_p   direct_optab_supported_p
 
#define direct_cond_binary_optab_supported_p   direct_optab_supported_p
 
#define direct_cond_ternary_optab_supported_p   direct_optab_supported_p
 
#define direct_cond_len_unary_optab_supported_p   direct_optab_supported_p
 
#define direct_cond_len_binary_optab_supported_p   direct_optab_supported_p
 
#define direct_cond_len_ternary_optab_supported_p   direct_optab_supported_p
 
#define direct_mask_load_optab_supported_p   convert_optab_supported_p
 
#define direct_load_lanes_optab_supported_p   multi_vector_optab_supported_p
 
#define direct_mask_load_lanes_optab_supported_p   multi_vector_optab_supported_p
 
#define direct_gather_load_optab_supported_p   convert_optab_supported_p
 
#define direct_len_load_optab_supported_p   direct_optab_supported_p
 
#define direct_mask_len_load_optab_supported_p   convert_optab_supported_p
 
#define direct_mask_store_optab_supported_p   convert_optab_supported_p
 
#define direct_store_lanes_optab_supported_p   multi_vector_optab_supported_p
 
#define direct_mask_store_lanes_optab_supported_p   multi_vector_optab_supported_p
 
#define direct_vec_cond_mask_optab_supported_p   convert_optab_supported_p
 
#define direct_vec_cond_optab_supported_p   convert_optab_supported_p
 
#define direct_scatter_store_optab_supported_p   convert_optab_supported_p
 
#define direct_len_store_optab_supported_p   direct_optab_supported_p
 
#define direct_mask_len_store_optab_supported_p   convert_optab_supported_p
 
#define direct_while_optab_supported_p   convert_optab_supported_p
 
#define direct_fold_extract_optab_supported_p   direct_optab_supported_p
 
#define direct_fold_len_extract_optab_supported_p   direct_optab_supported_p
 
#define direct_fold_left_optab_supported_p   direct_optab_supported_p
 
#define direct_mask_fold_left_optab_supported_p   direct_optab_supported_p
 
#define direct_mask_len_fold_left_optab_supported_p   direct_optab_supported_p
 
#define direct_check_ptrs_optab_supported_p   direct_optab_supported_p
 
#define direct_vec_set_optab_supported_p   direct_optab_supported_p
 
#define direct_vec_extract_optab_supported_p   convert_optab_supported_p
 
#define DEF_INTERNAL_FN(CODE, FLAGS, FNSPEC)
 
#define DEF_INTERNAL_OPTAB_FN(CODE, FLAGS, OPTAB, TYPE)
 
#define DEF_INTERNAL_SIGNED_OPTAB_FN(CODE, FLAGS, SELECTOR, SIGNED_OPTAB, UNSIGNED_OPTAB, TYPE)
 
#define DEF_INTERNAL_FLT_FN(NAME, FLAGS, OPTAB, TYPE)
 
#define DEF_INTERNAL_FLT_FLOATN_FN(NAME, FLAGS, OPTAB, TYPE)
 
#define DEF_INTERNAL_INT_FN(NAME, FLAGS, OPTAB, TYPE)
 
#define DEF_INTERNAL_INT_EXT_FN(NAME, FLAGS, OPTAB, TYPE)
 
#define DEF_INTERNAL_WIDENING_OPTAB_FN(NAME, FLAGS, SELECTOR, SOPTAB, UOPTAB, TYPE)
 
#define DEF_INTERNAL_COND_FN(NAME, FLAGS, OPTAB, TYPE)
 
#define DEF_INTERNAL_SIGNED_COND_FN(NAME, FLAGS, SELECTOR, SIGNED_OPTAB, UNSIGNED_OPTAB, TYPE)
 
#define DEF_INTERNAL_FN(CODE, FLAGS, FNSPEC)
 
#define DEF_INTERNAL_OPTAB_FN(CODE, FLAGS, OPTAB, TYPE)
 
#define DEF_INTERNAL_SIGNED_OPTAB_FN(NAME, FLAGS, SELECTOR, SIGNED_OPTAB, UNSIGNED_OPTAB, TYPE)
 
#define DEF_INTERNAL_FLT_FN(NAME, FLAGS, OPTAB, TYPE)
 
#define DEF_INTERNAL_FLT_FLOATN_FN(NAME, FLAGS, OPTAB, TYPE)
 
#define DEF_INTERNAL_INT_FN(NAME, FLAGS, OPTAB, TYPE)
 
#define DEF_INTERNAL_INT_EXT_FN(NAME, FLAGS, OPTAB, TYPE)
 
#define DEF_INTERNAL_WIDENING_OPTAB_FN(NAME, FLAGS, SELECTOR, SOPTAB, UOPTAB, TYPE)
 
#define DEF_INTERNAL_COND_FN(NAME, FLAGS, OPTAB, TYPE)
 
#define DEF_INTERNAL_SIGNED_COND_FN(NAME, FLAGS, SELECTOR, SIGNED_OPTAB, UNSIGNED_OPTAB, TYPE)
 
#define DEF_INTERNAL_FN(CODE, FLAGS, FNSPEC)
 
#define DEF_INTERNAL_OPTAB_FN(CODE, FLAGS, OPTAB, TYPE)
 
#define DEF_INTERNAL_SIGNED_OPTAB_FN(CODE, FLAGS, SELECTOR, SIGNED_OPTAB, UNSIGNED_OPTAB, TYPE)
 
#define DEF_INTERNAL_FLT_FN(NAME, FLAGS, OPTAB, TYPE)
 
#define DEF_INTERNAL_FLT_FLOATN_FN(NAME, FLAGS, OPTAB, TYPE)
 
#define DEF_INTERNAL_INT_FN(NAME, FLAGS, OPTAB, TYPE)
 
#define DEF_INTERNAL_INT_EXT_FN(NAME, FLAGS, OPTAB, TYPE)
 
#define DEF_INTERNAL_WIDENING_OPTAB_FN(NAME, FLAGS, SELECTOR, SOPTAB, UOPTAB, TYPE)
 
#define DEF_INTERNAL_COND_FN(NAME, FLAGS, OPTAB, TYPE)
 
#define DEF_INTERNAL_SIGNED_COND_FN(NAME, FLAGS, SELECTOR, SIGNED_OPTAB, UNSIGNED_OPTAB, TYPE)
 
#define DEF_INTERNAL_WIDENING_OPTAB_FN(NAME, F, S, SO, UO, T)
 
#define DEF_INTERNAL_FN(CODE, FLAGS, FNSPEC)
 
#define DEF_INTERNAL_OPTAB_FN(NAME, FLAGS, OPTAB, TYPE)
 
#define DEF_INTERNAL_SIGNED_OPTAB_FN(NAME, FLAGS, SELECTOR, SIGNED_OPTAB, UNSIGNED_OPTAB, TYPE)
 
#define DEF_INTERNAL_FLT_FN(NAME, FLAGS, OPTAB, TYPE)
 
#define DEF_INTERNAL_FLT_FLOATN_FN(NAME, FLAGS, OPTAB, TYPE)
 
#define DEF_INTERNAL_INT_FN(NAME, FLAGS, OPTAB, TYPE)
 
#define DEF_INTERNAL_INT_EXT_FN(NAME, FLAGS, OPTAB, TYPE)
 
#define DEF_INTERNAL_COND_FN(NAME, FLAGS, OPTAB, TYPE)
 
#define DEF_INTERNAL_SIGNED_COND_FN(NAME, FLAGS, SELECTOR, SIGNED_OPTAB, UNSIGNED_OPTAB, TYPE)
 
#define DEF_INTERNAL_OPTAB_FN(CODE, FLAGS, OPTAB, TYPE)
 
#define DEF_INTERNAL_INT_EXT_FN(CODE, FLAGS, OPTAB, TYPE)
 
#define DEF_INTERNAL_SIGNED_OPTAB_FN(CODE, FLAGS, SELECTOR, SIGNED_OPTAB, UNSIGNED_OPTAB, TYPE)
 
#define DEF_INTERNAL_FN(CODE, FLAGS, FNSPEC)
 
#define DEF_INTERNAL_FLT_FN(NAME, FLAGS, OPTAB, TYPE)
 
#define DEF_INTERNAL_FLT_FLOATN_FN(NAME, FLAGS, OPTAB, TYPE)
 
#define DEF_INTERNAL_INT_FN(NAME, FLAGS, OPTAB, TYPE)
 
#define DEF_INTERNAL_WIDENING_OPTAB_FN(NAME, FLAGS, SELECTOR, SOPTAB, UOPTAB, TYPE)
 
#define DEF_INTERNAL_COND_FN(NAME, FLAGS, OPTAB, TYPE)
 
#define DEF_INTERNAL_SIGNED_COND_FN(NAME, FLAGS, SELECTOR, SIGNED_OPTAB, UNSIGNED_OPTAB, TYPE)
 
#define FOR_EACH_CODE_MAPPING(T)
 
#define CASE(CODE, IFN)
 
#define CASE(CODE, IFN)
 
#define CASE(CODE, IFN)
 
#define FOR_EACH_COND_FN_PAIR(T)
 
#define CASE(NAME)
 
#define DEF_INTERNAL_COND_FN(NAME, ...)
 
#define DEF_INTERNAL_SIGNED_COND_FN(NAME, ...)
 
#define DEF_INTERNAL_FN(CODE, FLAGS, FNSPEC)
 
#define DEF_INTERNAL_OPTAB_FN(NAME, FLAGS, OPTAB, TYPE)
 
#define DEF_INTERNAL_SIGNED_OPTAB_FN(NAME, FLAGS, SELECTOR, SIGNED_OPTAB, UNSIGNED_OPTAB, TYPE)
 
#define DEF_INTERNAL_FLT_FN(NAME, FLAGS, OPTAB, TYPE)
 
#define DEF_INTERNAL_FLT_FLOATN_FN(NAME, FLAGS, OPTAB, TYPE)
 
#define DEF_INTERNAL_INT_FN(NAME, FLAGS, OPTAB, TYPE)
 
#define DEF_INTERNAL_INT_EXT_FN(NAME, FLAGS, OPTAB, TYPE)
 
#define DEF_INTERNAL_WIDENING_OPTAB_FN(NAME, FLAGS, SELECTOR, SOPTAB, UOPTAB, TYPE)
 
#define CASE(NAME)
 

Functions

internal_fn lookup_internal_fn (const char *name)
 
void lookup_hilo_internal_fn (internal_fn ifn, internal_fn *lo, internal_fn *hi)
 
void lookup_evenodd_internal_fn (internal_fn ifn, internal_fn *even, internal_fn *odd)
 
void init_internal_fns ()
 
static void create_call_lhs_operand (expand_operand *op, rtx lhs_rtx, machine_mode mode)
 
static void assign_call_lhs (tree lhs, rtx lhs_rtx, expand_operand *op)
 
static void expand_fn_using_insn (gcall *stmt, insn_code icode, unsigned int noutputs, unsigned int ninputs)
 
static enum insn_code get_multi_vector_move (tree array_type, convert_optab optab)
 
static unsigned int add_mask_and_len_args (expand_operand *ops, unsigned int opno, gcall *stmt)
 
static void expand_load_lanes_optab_fn (internal_fn, gcall *stmt, convert_optab optab)
 
static void expand_store_lanes_optab_fn (internal_fn, gcall *stmt, convert_optab optab)
 
static void expand_ANNOTATE (internal_fn, gcall *)
 
static void expand_GOMP_USE_SIMT (internal_fn, gcall *)
 
static void expand_GOMP_SIMT_ENTER (internal_fn, gcall *)
 
static void expand_GOMP_SIMT_ENTER_ALLOC (internal_fn, gcall *stmt)
 
static void expand_GOMP_SIMT_EXIT (internal_fn, gcall *stmt)
 
static void expand_GOMP_SIMT_LANE (internal_fn, gcall *stmt)
 
static void expand_GOMP_SIMT_VF (internal_fn, gcall *)
 
static void expand_GOMP_TARGET_REV (internal_fn, gcall *)
 
static void expand_GOMP_SIMT_LAST_LANE (internal_fn, gcall *stmt)
 
static void expand_GOMP_SIMT_ORDERED_PRED (internal_fn, gcall *stmt)
 
static void expand_GOMP_SIMT_VOTE_ANY (internal_fn, gcall *stmt)
 
static void expand_GOMP_SIMT_XCHG_BFLY (internal_fn, gcall *stmt)
 
static void expand_GOMP_SIMT_XCHG_IDX (internal_fn, gcall *stmt)
 
static void expand_GOMP_SIMD_LANE (internal_fn, gcall *)
 
static void expand_GOMP_SIMD_VF (internal_fn, gcall *)
 
static void expand_GOMP_SIMD_LAST_LANE (internal_fn, gcall *)
 
static void expand_GOMP_SIMD_ORDERED_START (internal_fn, gcall *)
 
static void expand_GOMP_SIMD_ORDERED_END (internal_fn, gcall *)
 
static void expand_UBSAN_NULL (internal_fn, gcall *)
 
static void expand_UBSAN_BOUNDS (internal_fn, gcall *)
 
static void expand_UBSAN_VPTR (internal_fn, gcall *)
 
static void expand_UBSAN_PTR (internal_fn, gcall *)
 
static void expand_UBSAN_OBJECT_SIZE (internal_fn, gcall *)
 
static void expand_HWASAN_CHECK (internal_fn, gcall *)
 
static void expand_HWASAN_ALLOCA_UNPOISON (internal_fn, gcall *gc)
 
static void expand_HWASAN_CHOOSE_TAG (internal_fn, gcall *gc)
 
static void expand_HWASAN_MARK (internal_fn, gcall *gc)
 
static void expand_HWASAN_SET_TAG (internal_fn, gcall *gc)
 
static void expand_ASAN_CHECK (internal_fn, gcall *)
 
static void expand_ASAN_MARK (internal_fn, gcall *)
 
static void expand_ASAN_POISON (internal_fn, gcall *)
 
static void expand_ASAN_POISON_USE (internal_fn, gcall *)
 
static void expand_TSAN_FUNC_EXIT (internal_fn, gcall *)
 
static void expand_FALLTHROUGH (internal_fn, gcall *call)
 
static int get_min_precision (tree arg, signop sign)
 
static void expand_arith_set_overflow (tree lhs, rtx target)
 
static void expand_arith_overflow_result_store (tree lhs, rtx target, scalar_int_mode mode, rtx res)
 
static void expand_ubsan_result_store (tree lhs, rtx target, scalar_int_mode mode, rtx res, rtx_code_label *do_error)
 
void expand_addsub_overflow (location_t loc, tree_code code, tree lhs, tree arg0, tree arg1, bool unsr_p, bool uns0_p, bool uns1_p, bool is_ubsan, tree *datap)
 
static void expand_neg_overflow (location_t loc, tree lhs, tree arg1, bool is_ubsan, tree *datap)
 
static bool can_widen_mult_without_libcall (scalar_int_mode wmode, scalar_int_mode mode, rtx op0, rtx op1, bool uns)
 
static void expand_mul_overflow (location_t loc, tree lhs, tree arg0, tree arg1, bool unsr_p, bool uns0_p, bool uns1_p, bool is_ubsan, tree *datap)
 
static void expand_vector_ubsan_overflow (location_t loc, enum tree_code code, tree lhs, tree arg0, tree arg1)
 
static void expand_UBSAN_CHECK_ADD (internal_fn, gcall *stmt)
 
static void expand_UBSAN_CHECK_SUB (internal_fn, gcall *stmt)
 
static void expand_UBSAN_CHECK_MUL (internal_fn, gcall *stmt)
 
static void expand_arith_overflow (enum tree_code code, gimple *stmt)
 
static void expand_ADD_OVERFLOW (internal_fn, gcall *stmt)
 
static void expand_SUB_OVERFLOW (internal_fn, gcall *stmt)
 
static void expand_MUL_OVERFLOW (internal_fn, gcall *stmt)
 
static void expand_UADDC (internal_fn ifn, gcall *stmt)
 
static void expand_USUBC (internal_fn ifn, gcall *stmt)
 
static void expand_LOOP_VECTORIZED (internal_fn, gcall *)
 
static void expand_LOOP_DIST_ALIAS (internal_fn, gcall *)
 
static tree expand_call_mem_ref (tree type, gcall *stmt, int index)
 
static void expand_partial_load_optab_fn (internal_fn ifn, gcall *stmt, convert_optab optab)
 
static void expand_partial_store_optab_fn (internal_fn ifn, gcall *stmt, convert_optab optab)
 
static void expand_vec_cond_optab_fn (internal_fn, gcall *stmt, convert_optab optab)
 
static void expand_vec_cond_mask_optab_fn (internal_fn, gcall *stmt, convert_optab optab)
 
static void expand_vec_set_optab_fn (internal_fn, gcall *stmt, convert_optab optab)
 
static void expand_ABNORMAL_DISPATCHER (internal_fn, gcall *)
 
static void expand_BUILTIN_EXPECT (internal_fn, gcall *stmt)
 
static void expand_VA_ARG (internal_fn, gcall *)
 
static void expand_VEC_CONVERT (internal_fn, gcall *)
 
void expand_RAWMEMCHR (internal_fn, gcall *stmt)
 
static void expand_UNIQUE (internal_fn, gcall *stmt)
 
static void expand_DEFERRED_INIT (internal_fn, gcall *stmt)
 
static void expand_ACCESS_WITH_SIZE (internal_fn, gcall *stmt)
 
static void expand_GOACC_DIM_SIZE (internal_fn, gcall *stmt)
 
static void expand_GOACC_DIM_POS (internal_fn, gcall *stmt)
 
static void expand_GOACC_LOOP (internal_fn, gcall *)
 
static void expand_GOACC_REDUCTION (internal_fn, gcall *)
 
static void expand_GOACC_TILE (internal_fn, gcall *)
 
static void expand_SET_EDOM (internal_fn, gcall *)
 
static void expand_ATOMIC_BIT_TEST_AND_SET (internal_fn, gcall *call)
 
static void expand_ATOMIC_BIT_TEST_AND_COMPLEMENT (internal_fn, gcall *call)
 
static void expand_ATOMIC_BIT_TEST_AND_RESET (internal_fn, gcall *call)
 
static void expand_ATOMIC_COMPARE_EXCHANGE (internal_fn, gcall *call)
 
static void expand_ATOMIC_ADD_FETCH_CMP_0 (internal_fn, gcall *call)
 
static void expand_ATOMIC_SUB_FETCH_CMP_0 (internal_fn, gcall *call)
 
static void expand_ATOMIC_AND_FETCH_CMP_0 (internal_fn, gcall *call)
 
static void expand_ATOMIC_OR_FETCH_CMP_0 (internal_fn, gcall *call)
 
static void expand_ATOMIC_XOR_FETCH_CMP_0 (internal_fn, gcall *call)
 
static void expand_LAUNDER (internal_fn, gcall *call)
 
static void expand_scatter_store_optab_fn (internal_fn, gcall *stmt, direct_optab optab)
 
static void expand_gather_load_optab_fn (internal_fn, gcall *stmt, direct_optab optab)
 
static bool contains_call_div_mod (rtx_insn *insn)
 
static void expand_DIVMOD (internal_fn, gcall *call_stmt)
 
static void expand_NOP (internal_fn, gcall *)
 
static void expand_CO_FRAME (internal_fn, gcall *)
 
static void expand_CO_YIELD (internal_fn, gcall *)
 
static void expand_CO_SUSPN (internal_fn, gcall *)
 
static void expand_CO_ACTOR (internal_fn, gcall *)
 
static void expand_direct_optab_fn (internal_fn fn, gcall *stmt, direct_optab optab, unsigned int nargs)
 
static void expand_while_optab_fn (internal_fn, gcall *stmt, convert_optab optab)
 
static void expand_convert_optab_fn (internal_fn fn, gcall *stmt, convert_optab optab, unsigned int nargs)
 
tree_pair direct_internal_fn_types (internal_fn fn, tree return_type, tree *args)
 
tree_pair direct_internal_fn_types (internal_fn fn, gcall *call)
 
static bool direct_optab_supported_p (direct_optab optab, tree_pair types, optimization_type opt_type)
 
static bool convert_optab_supported_p (convert_optab optab, tree_pair types, optimization_type opt_type)
 
static bool multi_vector_optab_supported_p (convert_optab optab, tree_pair types, optimization_type opt_type)
 
optab direct_internal_fn_optab (internal_fn fn, tree_pair types)
 
static optab direct_internal_fn_optab (internal_fn fn)
 
static bool type_strictly_matches_mode_p (const_tree type)
 
static bool type_pair_strictly_matches_mode_p (tree_pair type_pair)
 
bool direct_internal_fn_supported_p (internal_fn fn, tree_pair types, optimization_type opt_type)
 
bool direct_internal_fn_supported_p (internal_fn fn, tree type, optimization_type opt_type)
 
bool direct_internal_fn_supported_p (gcall *stmt, optimization_type opt_type)
 
bool commutative_binary_fn_p (internal_fn fn)
 
bool commutative_ternary_fn_p (internal_fn fn)
 
bool associative_binary_fn_p (internal_fn fn)
 
int first_commutative_argument (internal_fn fn)
 
bool widening_fn_p (code_helper code)
 
bool set_edom_supported_p (void)
 
internal_fn get_conditional_internal_fn (tree_code code)
 
tree_code conditional_internal_fn_code (internal_fn ifn)
 
internal_fn get_conditional_len_internal_fn (tree_code code)
 
internal_fn get_conditional_internal_fn (internal_fn fn)
 
internal_fn get_len_internal_fn (internal_fn fn)
 
internal_fn get_unconditional_internal_fn (internal_fn ifn)
 
bool can_interpret_as_conditional_op_p (gimple *stmt, tree *cond_out, tree_code *code_out, tree(&ops)[3], tree *else_out, tree *len, tree *bias)
 
bool internal_load_fn_p (internal_fn fn)
 
bool internal_store_fn_p (internal_fn fn)
 
bool internal_gather_scatter_fn_p (internal_fn fn)
 
int internal_fn_len_index (internal_fn fn)
 
int internal_fn_else_index (internal_fn fn)
 
int internal_fn_mask_index (internal_fn fn)
 
int internal_fn_stored_value_index (internal_fn fn)
 
bool internal_gather_scatter_fn_supported_p (internal_fn ifn, tree vector_type, tree memory_element_type, tree offset_vector_type, int scale)
 
bool internal_check_ptrs_fn_supported_p (internal_fn ifn, tree type, poly_uint64 length, unsigned int align)
 
signed char internal_len_load_store_bias (internal_fn ifn, machine_mode mode)
 
void expand_internal_call (internal_fn fn, gcall *stmt)
 
void expand_internal_call (gcall *stmt)
 
bool vectorized_internal_fn_supported_p (internal_fn ifn, tree type)
 
void expand_SHUFFLEVECTOR (internal_fn, gcall *)
 
void expand_PHI (internal_fn, gcall *)
 
void expand_SPACESHIP (internal_fn, gcall *stmt)
 
void expand_ASSUME (internal_fn, gcall *)
 
void expand_MASK_CALL (internal_fn, gcall *)
 
void expand_MULBITINT (internal_fn, gcall *stmt)
 
void expand_DIVMODBITINT (internal_fn, gcall *stmt)
 
void expand_FLOATTOBITINT (internal_fn, gcall *stmt)
 
void expand_BITINTTOFLOAT (internal_fn, gcall *stmt)
 
static bool expand_bitquery (internal_fn fn, gcall *stmt)
 
void expand_CLRSB (internal_fn fn, gcall *stmt)
 
void expand_CLZ (internal_fn fn, gcall *stmt)
 
void expand_CTZ (internal_fn fn, gcall *stmt)
 
void expand_FFS (internal_fn fn, gcall *stmt)
 
void expand_PARITY (internal_fn fn, gcall *stmt)
 
void expand_POPCOUNT (internal_fn fn, gcall *stmt)
 

Variables

const char *const internal_fn_name_array []
 
const int internal_fn_flags_array []
 
const_tree internal_fn_fnspec_array [IFN_LAST+1]
 
const direct_internal_fn_info direct_internal_fn_array [IFN_LAST+1]
 
static void(*const internal_fn_expanders [])(internal_fn, gcall *)
 

Macro Definition Documentation

◆ binary_direct

#define binary_direct   { 0, 0, true }

◆ CASE [1/5]

#define CASE ( CODE,
IFN )
Value:
case CODE: return IFN_COND_##IFN;

Referenced by conditional_internal_fn_code(), get_conditional_internal_fn(), get_conditional_internal_fn(), get_conditional_len_internal_fn(), and get_unconditional_internal_fn().

◆ CASE [2/5]

#define CASE ( CODE,
IFN )
Value:
case IFN_COND_##IFN: \
case IFN_COND_LEN_##IFN: \
return CODE;

◆ CASE [3/5]

#define CASE ( CODE,
IFN )
Value:
case CODE: return IFN_COND_LEN_##IFN;

◆ CASE [4/5]

#define CASE ( NAME)
Value:
case IFN_##NAME: return IFN_COND_##NAME;
NAME
@ NAME
Definition tree-ssa-pre.cc:242

◆ CASE [5/5]

#define CASE ( NAME)
Value:
case IFN_COND_##NAME: \
case IFN_COND_LEN_##NAME: \
return IFN_##NAME;

◆ check_ptrs_direct

#define check_ptrs_direct   { 0, 0, false }

◆ cond_binary_direct

#define cond_binary_direct   { 1, 1, true }

◆ cond_len_binary_direct

#define cond_len_binary_direct   { 1, 1, true }

◆ cond_len_ternary_direct

#define cond_len_ternary_direct   { 1, 1, true }

◆ cond_len_unary_direct

#define cond_len_unary_direct   { 1, 1, true }

◆ cond_ternary_direct

#define cond_ternary_direct   { 1, 1, true }

◆ cond_unary_direct

#define cond_unary_direct   { 1, 1, true }

◆ DEF_INTERNAL_COND_FN [1/12]

#define DEF_INTERNAL_COND_FN ( NAME,
FLAGS,
OPTAB,
TYPE )
Value:
DEF_INTERNAL_OPTAB_FN (COND_##NAME, FLAGS, cond_##OPTAB, cond_##TYPE) \
DEF_INTERNAL_OPTAB_FN (COND_LEN_##NAME, FLAGS, cond_len_##OPTAB, \
cond_len_##TYPE)

◆ DEF_INTERNAL_COND_FN [2/12]

#define DEF_INTERNAL_COND_FN ( NAME,
FLAGS,
OPTAB,
TYPE )
Value:
DEF_INTERNAL_OPTAB_FN (COND_##NAME, FLAGS, cond_##OPTAB, cond_##TYPE) \
DEF_INTERNAL_OPTAB_FN (COND_LEN_##NAME, FLAGS, cond_len_##OPTAB, \
cond_len_##TYPE)

◆ DEF_INTERNAL_COND_FN [3/12]

#define DEF_INTERNAL_COND_FN ( NAME,
FLAGS,
OPTAB,
TYPE )
Value:
DEF_INTERNAL_OPTAB_FN (COND_##NAME, FLAGS, cond_##OPTAB, cond_##TYPE) \
DEF_INTERNAL_OPTAB_FN (COND_LEN_##NAME, FLAGS, cond_len_##OPTAB, \
cond_len_##TYPE)

◆ DEF_INTERNAL_COND_FN [4/12]

#define DEF_INTERNAL_COND_FN ( NAME,
FLAGS,
OPTAB,
TYPE )
Value:
DEF_INTERNAL_OPTAB_FN (COND_##NAME, FLAGS, cond_##OPTAB, cond_##TYPE) \
DEF_INTERNAL_OPTAB_FN (COND_LEN_##NAME, FLAGS, cond_len_##OPTAB, \
cond_len_##TYPE)

◆ DEF_INTERNAL_COND_FN [5/12]

#define DEF_INTERNAL_COND_FN ( NAME,
FLAGS,
OPTAB,
TYPE )
Value:
DEF_INTERNAL_OPTAB_FN (COND_##NAME, FLAGS, cond_##OPTAB, cond_##TYPE) \
DEF_INTERNAL_OPTAB_FN (COND_LEN_##NAME, FLAGS, cond_len_##OPTAB, \
cond_len_##TYPE)

◆ DEF_INTERNAL_COND_FN [6/12]

#define DEF_INTERNAL_COND_FN ( NAME,
FLAGS,
OPTAB,
TYPE )
Value:
DEF_INTERNAL_OPTAB_FN (COND_##NAME, FLAGS, cond_##OPTAB, cond_##TYPE) \
DEF_INTERNAL_OPTAB_FN (COND_LEN_##NAME, FLAGS, cond_len_##OPTAB, \
cond_len_##TYPE)

◆ DEF_INTERNAL_COND_FN [7/12]

#define DEF_INTERNAL_COND_FN ( NAME,
FLAGS,
OPTAB,
TYPE )
Value:
DEF_INTERNAL_OPTAB_FN (COND_##NAME, FLAGS, cond_##OPTAB, cond_##TYPE) \
DEF_INTERNAL_OPTAB_FN (COND_LEN_##NAME, FLAGS, cond_len_##OPTAB, \
cond_len_##TYPE)

◆ DEF_INTERNAL_COND_FN [8/12]

#define DEF_INTERNAL_COND_FN ( NAME,
FLAGS,
OPTAB,
TYPE )
Value:
DEF_INTERNAL_OPTAB_FN (COND_##NAME, FLAGS, cond_##OPTAB, cond_##TYPE) \
DEF_INTERNAL_OPTAB_FN (COND_LEN_##NAME, FLAGS, cond_len_##OPTAB, \
cond_len_##TYPE)

◆ DEF_INTERNAL_COND_FN [9/12]

#define DEF_INTERNAL_COND_FN ( NAME,
FLAGS,
OPTAB,
TYPE )
Value:
DEF_INTERNAL_OPTAB_FN (COND_##NAME, FLAGS, cond_##OPTAB, cond_##TYPE) \
DEF_INTERNAL_OPTAB_FN (COND_LEN_##NAME, FLAGS, cond_len_##OPTAB, \
cond_len_##TYPE)

◆ DEF_INTERNAL_COND_FN [10/12]

#define DEF_INTERNAL_COND_FN ( NAME,
FLAGS,
OPTAB,
TYPE )
Value:
DEF_INTERNAL_OPTAB_FN (COND_##NAME, FLAGS, cond_##OPTAB, cond_##TYPE) \
DEF_INTERNAL_OPTAB_FN (COND_LEN_##NAME, FLAGS, cond_len_##OPTAB, \
cond_len_##TYPE)

◆ DEF_INTERNAL_COND_FN [11/12]

#define DEF_INTERNAL_COND_FN ( NAME,
FLAGS,
OPTAB,
TYPE )
Value:
DEF_INTERNAL_OPTAB_FN (COND_##NAME, FLAGS, cond_##OPTAB, cond_##TYPE) \
DEF_INTERNAL_OPTAB_FN (COND_LEN_##NAME, FLAGS, cond_len_##OPTAB, \
cond_len_##TYPE)

◆ DEF_INTERNAL_COND_FN [12/12]

#define DEF_INTERNAL_COND_FN ( NAME,
... )
Value:
case IFN_COND_##NAME: \
return IFN_COND_LEN_##NAME;

◆ DEF_INTERNAL_FLT_FLOATN_FN [1/12]

#define DEF_INTERNAL_FLT_FLOATN_FN ( NAME,
FLAGS,
OPTAB,
TYPE )
Value:
DEF_INTERNAL_FLT_FN (NAME, FLAGS, OPTAB, TYPE)

◆ DEF_INTERNAL_FLT_FLOATN_FN [2/12]

#define DEF_INTERNAL_FLT_FLOATN_FN ( NAME,
FLAGS,
OPTAB,
TYPE )
Value:
DEF_INTERNAL_FLT_FN (NAME, FLAGS, OPTAB, TYPE)

◆ DEF_INTERNAL_FLT_FLOATN_FN [3/12]

#define DEF_INTERNAL_FLT_FLOATN_FN ( NAME,
FLAGS,
OPTAB,
TYPE )
Value:
DEF_INTERNAL_FLT_FN (NAME, FLAGS, OPTAB, TYPE)

◆ DEF_INTERNAL_FLT_FLOATN_FN [4/12]

#define DEF_INTERNAL_FLT_FLOATN_FN ( NAME,
FLAGS,
OPTAB,
TYPE )
Value:
DEF_INTERNAL_FLT_FN (NAME, FLAGS, OPTAB, TYPE)

◆ DEF_INTERNAL_FLT_FLOATN_FN [5/12]

#define DEF_INTERNAL_FLT_FLOATN_FN ( NAME,
FLAGS,
OPTAB,
TYPE )
Value:
DEF_INTERNAL_FLT_FN (NAME, FLAGS, OPTAB, TYPE)

◆ DEF_INTERNAL_FLT_FLOATN_FN [6/12]

#define DEF_INTERNAL_FLT_FLOATN_FN ( NAME,
FLAGS,
OPTAB,
TYPE )
Value:
DEF_INTERNAL_FLT_FN (NAME, FLAGS, OPTAB, TYPE)

◆ DEF_INTERNAL_FLT_FLOATN_FN [7/12]

#define DEF_INTERNAL_FLT_FLOATN_FN ( NAME,
FLAGS,
OPTAB,
TYPE )
Value:
DEF_INTERNAL_FLT_FN (NAME, FLAGS, OPTAB, TYPE)

◆ DEF_INTERNAL_FLT_FLOATN_FN [8/12]

#define DEF_INTERNAL_FLT_FLOATN_FN ( NAME,
FLAGS,
OPTAB,
TYPE )
Value:
DEF_INTERNAL_FLT_FN (NAME, FLAGS, OPTAB, TYPE)

◆ DEF_INTERNAL_FLT_FLOATN_FN [9/12]

#define DEF_INTERNAL_FLT_FLOATN_FN ( NAME,
FLAGS,
OPTAB,
TYPE )
Value:
DEF_INTERNAL_FLT_FN (NAME, FLAGS, OPTAB, TYPE)

◆ DEF_INTERNAL_FLT_FLOATN_FN [10/12]

#define DEF_INTERNAL_FLT_FLOATN_FN ( NAME,
FLAGS,
OPTAB,
TYPE )
Value:
DEF_INTERNAL_FLT_FN (NAME, FLAGS, OPTAB, TYPE)

◆ DEF_INTERNAL_FLT_FLOATN_FN [11/12]

#define DEF_INTERNAL_FLT_FLOATN_FN ( NAME,
FLAGS,
OPTAB,
TYPE )
Value:
DEF_INTERNAL_FLT_FN (NAME, FLAGS, OPTAB, TYPE)

◆ DEF_INTERNAL_FLT_FLOATN_FN [12/12]

#define DEF_INTERNAL_FLT_FLOATN_FN ( NAME,
FLAGS,
OPTAB,
TYPE )
Value:
DEF_INTERNAL_FLT_FN (NAME, FLAGS, OPTAB, TYPE)

◆ DEF_INTERNAL_FLT_FN [1/12]

#define DEF_INTERNAL_FLT_FN ( NAME,
FLAGS,
OPTAB,
TYPE )
Value:
DEF_INTERNAL_OPTAB_FN (NAME, FLAGS, OPTAB, TYPE)

◆ DEF_INTERNAL_FLT_FN [2/12]

#define DEF_INTERNAL_FLT_FN ( NAME,
FLAGS,
OPTAB,
TYPE )
Value:
DEF_INTERNAL_OPTAB_FN (NAME, FLAGS, OPTAB, TYPE)

◆ DEF_INTERNAL_FLT_FN [3/12]

#define DEF_INTERNAL_FLT_FN ( NAME,
FLAGS,
OPTAB,
TYPE )
Value:
DEF_INTERNAL_OPTAB_FN (NAME, FLAGS, OPTAB, TYPE)

◆ DEF_INTERNAL_FLT_FN [4/12]

#define DEF_INTERNAL_FLT_FN ( NAME,
FLAGS,
OPTAB,
TYPE )
Value:
DEF_INTERNAL_OPTAB_FN (NAME, FLAGS, OPTAB, TYPE)

◆ DEF_INTERNAL_FLT_FN [5/12]

#define DEF_INTERNAL_FLT_FN ( NAME,
FLAGS,
OPTAB,
TYPE )
Value:
DEF_INTERNAL_OPTAB_FN (NAME, FLAGS, OPTAB, TYPE)

◆ DEF_INTERNAL_FLT_FN [6/12]

#define DEF_INTERNAL_FLT_FN ( NAME,
FLAGS,
OPTAB,
TYPE )
Value:
DEF_INTERNAL_OPTAB_FN (NAME, FLAGS, OPTAB, TYPE)

◆ DEF_INTERNAL_FLT_FN [7/12]

#define DEF_INTERNAL_FLT_FN ( NAME,
FLAGS,
OPTAB,
TYPE )
Value:
DEF_INTERNAL_OPTAB_FN (NAME, FLAGS, OPTAB, TYPE)

◆ DEF_INTERNAL_FLT_FN [8/12]

#define DEF_INTERNAL_FLT_FN ( NAME,
FLAGS,
OPTAB,
TYPE )
Value:
DEF_INTERNAL_OPTAB_FN (NAME, FLAGS, OPTAB, TYPE)

◆ DEF_INTERNAL_FLT_FN [9/12]

#define DEF_INTERNAL_FLT_FN ( NAME,
FLAGS,
OPTAB,
TYPE )
Value:
DEF_INTERNAL_OPTAB_FN (NAME, FLAGS, OPTAB, TYPE)

◆ DEF_INTERNAL_FLT_FN [10/12]

#define DEF_INTERNAL_FLT_FN ( NAME,
FLAGS,
OPTAB,
TYPE )
Value:
DEF_INTERNAL_OPTAB_FN (NAME, FLAGS, OPTAB, TYPE)

◆ DEF_INTERNAL_FLT_FN [11/12]

#define DEF_INTERNAL_FLT_FN ( NAME,
FLAGS,
OPTAB,
TYPE )
Value:
DEF_INTERNAL_OPTAB_FN (NAME, FLAGS, OPTAB, TYPE)

◆ DEF_INTERNAL_FLT_FN [12/12]

#define DEF_INTERNAL_FLT_FN ( NAME,
FLAGS,
OPTAB,
TYPE )
Value:
DEF_INTERNAL_OPTAB_FN (NAME, FLAGS, OPTAB, TYPE)

◆ DEF_INTERNAL_FN [1/12]

#define DEF_INTERNAL_FN ( CODE,
FLAGS,
FNSPEC )
Value:
#CODE,

◆ DEF_INTERNAL_FN [2/12]

#define DEF_INTERNAL_FN ( CODE,
FLAGS,
FNSPEC )
Value:
FLAGS,

◆ DEF_INTERNAL_FN [3/12]

#define DEF_INTERNAL_FN ( CODE,
FLAGS,
FNSPEC )
Value:
if (FNSPEC) internal_fn_fnspec_array[IFN_##CODE] = \
build_string ((int) sizeof (FNSPEC) - 1, FNSPEC ? FNSPEC : "");
internal_fn_fnspec_array
const_tree internal_fn_fnspec_array[IFN_LAST+1]
Definition internal-fn.cc:143

◆ DEF_INTERNAL_FN [4/12]

#define DEF_INTERNAL_FN ( CODE,
FLAGS,
FNSPEC )
Value:
not_direct,
not_direct
#define not_direct
Definition internal-fn.cc:157

◆ DEF_INTERNAL_FN [5/12]

#define DEF_INTERNAL_FN ( CODE,
FLAGS,
FNSPEC )
Value:
case IFN_##CODE: break;

◆ DEF_INTERNAL_FN [6/12]

#define DEF_INTERNAL_FN ( CODE,
FLAGS,
FNSPEC )
Value:
case IFN_##CODE: break;

◆ DEF_INTERNAL_FN [7/12]

#define DEF_INTERNAL_FN ( CODE,
FLAGS,
FNSPEC )
Value:
case IFN_##CODE: break;

◆ DEF_INTERNAL_FN [8/12]

#define DEF_INTERNAL_FN ( CODE,
FLAGS,
FNSPEC )
Value:
expand_##CODE,

◆ DEF_INTERNAL_FN [9/12]

#define DEF_INTERNAL_FN ( CODE,
FLAGS,
FNSPEC )

◆ DEF_INTERNAL_FN [10/12]

#define DEF_INTERNAL_FN ( CODE,
FLAGS,
FNSPEC )

◆ DEF_INTERNAL_FN [11/12]

#define DEF_INTERNAL_FN ( NAME,
FLAGS,
TYPE )

◆ DEF_INTERNAL_FN [12/12]

#define DEF_INTERNAL_FN ( NAME,
FLAGS,
TYPE )

◆ DEF_INTERNAL_INT_EXT_FN [1/12]

#define DEF_INTERNAL_INT_EXT_FN ( CODE,
FLAGS,
OPTAB,
TYPE )

◆ DEF_INTERNAL_INT_EXT_FN [2/12]

#define DEF_INTERNAL_INT_EXT_FN ( NAME,
FLAGS,
OPTAB,
TYPE )
Value:
DEF_INTERNAL_INT_FN (NAME, FLAGS, OPTAB, TYPE)

◆ DEF_INTERNAL_INT_EXT_FN [3/12]

#define DEF_INTERNAL_INT_EXT_FN ( NAME,
FLAGS,
OPTAB,
TYPE )
Value:
DEF_INTERNAL_INT_FN (NAME, FLAGS, OPTAB, TYPE)

◆ DEF_INTERNAL_INT_EXT_FN [4/12]

#define DEF_INTERNAL_INT_EXT_FN ( NAME,
FLAGS,
OPTAB,
TYPE )
Value:
DEF_INTERNAL_INT_FN (NAME, FLAGS, OPTAB, TYPE)

◆ DEF_INTERNAL_INT_EXT_FN [5/12]

#define DEF_INTERNAL_INT_EXT_FN ( NAME,
FLAGS,
OPTAB,
TYPE )
Value:
DEF_INTERNAL_INT_FN (NAME, FLAGS, OPTAB, TYPE)

◆ DEF_INTERNAL_INT_EXT_FN [6/12]

#define DEF_INTERNAL_INT_EXT_FN ( NAME,
FLAGS,
OPTAB,
TYPE )
Value:
DEF_INTERNAL_INT_FN (NAME, FLAGS, OPTAB, TYPE)

◆ DEF_INTERNAL_INT_EXT_FN [7/12]

#define DEF_INTERNAL_INT_EXT_FN ( NAME,
FLAGS,
OPTAB,
TYPE )
Value:
DEF_INTERNAL_INT_FN (NAME, FLAGS, OPTAB, TYPE)

◆ DEF_INTERNAL_INT_EXT_FN [8/12]

#define DEF_INTERNAL_INT_EXT_FN ( NAME,
FLAGS,
OPTAB,
TYPE )
Value:
DEF_INTERNAL_INT_FN (NAME, FLAGS, OPTAB, TYPE)

◆ DEF_INTERNAL_INT_EXT_FN [9/12]

#define DEF_INTERNAL_INT_EXT_FN ( NAME,
FLAGS,
OPTAB,
TYPE )
Value:
DEF_INTERNAL_INT_FN (NAME, FLAGS, OPTAB, TYPE)

◆ DEF_INTERNAL_INT_EXT_FN [10/12]

#define DEF_INTERNAL_INT_EXT_FN ( NAME,
FLAGS,
OPTAB,
TYPE )
Value:
DEF_INTERNAL_INT_FN (NAME, FLAGS, OPTAB, TYPE)

◆ DEF_INTERNAL_INT_EXT_FN [11/12]

#define DEF_INTERNAL_INT_EXT_FN ( NAME,
FLAGS,
OPTAB,
TYPE )
Value:
DEF_INTERNAL_INT_FN (NAME, FLAGS, OPTAB, TYPE)

◆ DEF_INTERNAL_INT_EXT_FN [12/12]

#define DEF_INTERNAL_INT_EXT_FN ( NAME,
FLAGS,
OPTAB,
TYPE )
Value:
DEF_INTERNAL_INT_FN (NAME, FLAGS, OPTAB, TYPE)

◆ DEF_INTERNAL_INT_FN [1/12]

#define DEF_INTERNAL_INT_FN ( NAME,
FLAGS,
OPTAB,
TYPE )
Value:
DEF_INTERNAL_OPTAB_FN (NAME, FLAGS, OPTAB, TYPE)

◆ DEF_INTERNAL_INT_FN [2/12]

#define DEF_INTERNAL_INT_FN ( NAME,
FLAGS,
OPTAB,
TYPE )
Value:
DEF_INTERNAL_OPTAB_FN (NAME, FLAGS, OPTAB, TYPE)

◆ DEF_INTERNAL_INT_FN [3/12]

#define DEF_INTERNAL_INT_FN ( NAME,
FLAGS,
OPTAB,
TYPE )
Value:
DEF_INTERNAL_OPTAB_FN (NAME, FLAGS, OPTAB, TYPE)

◆ DEF_INTERNAL_INT_FN [4/12]

#define DEF_INTERNAL_INT_FN ( NAME,
FLAGS,
OPTAB,
TYPE )
Value:
DEF_INTERNAL_OPTAB_FN (NAME, FLAGS, OPTAB, TYPE)

◆ DEF_INTERNAL_INT_FN [5/12]

#define DEF_INTERNAL_INT_FN ( NAME,
FLAGS,
OPTAB,
TYPE )
Value:
DEF_INTERNAL_OPTAB_FN (NAME, FLAGS, OPTAB, TYPE)

◆ DEF_INTERNAL_INT_FN [6/12]

#define DEF_INTERNAL_INT_FN ( NAME,
FLAGS,
OPTAB,
TYPE )
Value:
DEF_INTERNAL_OPTAB_FN (NAME, FLAGS, OPTAB, TYPE)

◆ DEF_INTERNAL_INT_FN [7/12]

#define DEF_INTERNAL_INT_FN ( NAME,
FLAGS,
OPTAB,
TYPE )
Value:
DEF_INTERNAL_OPTAB_FN (NAME, FLAGS, OPTAB, TYPE)

◆ DEF_INTERNAL_INT_FN [8/12]

#define DEF_INTERNAL_INT_FN ( NAME,
FLAGS,
OPTAB,
TYPE )
Value:
DEF_INTERNAL_OPTAB_FN (NAME, FLAGS, OPTAB, TYPE)

◆ DEF_INTERNAL_INT_FN [9/12]

#define DEF_INTERNAL_INT_FN ( NAME,
FLAGS,
OPTAB,
TYPE )
Value:
DEF_INTERNAL_OPTAB_FN (NAME, FLAGS, OPTAB, TYPE)

◆ DEF_INTERNAL_INT_FN [10/12]

#define DEF_INTERNAL_INT_FN ( NAME,
FLAGS,
OPTAB,
TYPE )
Value:
DEF_INTERNAL_OPTAB_FN (NAME, FLAGS, OPTAB, TYPE)

◆ DEF_INTERNAL_INT_FN [11/12]

#define DEF_INTERNAL_INT_FN ( NAME,
FLAGS,
OPTAB,
TYPE )
Value:
DEF_INTERNAL_OPTAB_FN (NAME, FLAGS, OPTAB, TYPE)

◆ DEF_INTERNAL_INT_FN [12/12]

#define DEF_INTERNAL_INT_FN ( NAME,
FLAGS,
OPTAB,
TYPE )
Value:
DEF_INTERNAL_OPTAB_FN (NAME, FLAGS, OPTAB, TYPE)

◆ DEF_INTERNAL_OPTAB_FN [1/12]

#define DEF_INTERNAL_OPTAB_FN ( CODE,
FLAGS,
OPTAB,
TYPE )
Value:
TYPE##_direct,

◆ DEF_INTERNAL_OPTAB_FN [2/12]

#define DEF_INTERNAL_OPTAB_FN ( CODE,
FLAGS,
OPTAB,
TYPE )
Value:
case IFN_##CODE: return OPTAB##_optab;

◆ DEF_INTERNAL_OPTAB_FN [3/12]

#define DEF_INTERNAL_OPTAB_FN ( CODE,
FLAGS,
OPTAB,
TYPE )
Value:
case IFN_##CODE: return OPTAB##_optab;

◆ DEF_INTERNAL_OPTAB_FN [4/12]

#define DEF_INTERNAL_OPTAB_FN ( CODE,
FLAGS,
OPTAB,
TYPE )
Value:
case IFN_##CODE: \
return direct_##TYPE##_optab_supported_p (OPTAB##_optab, types, \
opt_type);

◆ DEF_INTERNAL_OPTAB_FN [5/12]

#define DEF_INTERNAL_OPTAB_FN ( CODE,
FLAGS,
OPTAB,
TYPE )
Value:
static void \
expand_##CODE (internal_fn fn, gcall *stmt) \
{ \
expand_##TYPE##_optab_fn (fn, stmt, OPTAB##_optab); \
}
internal_fn
internal_fn
Definition genmatch.cc:360
gcall
Definition gimple.h:349

◆ DEF_INTERNAL_OPTAB_FN [6/12]

#define DEF_INTERNAL_OPTAB_FN ( NAME,
FLAGS,
OPTAB,
TYPE )
Value:
DEF_INTERNAL_FN (NAME, FLAGS | ECF_LEAF, NULL)

◆ DEF_INTERNAL_OPTAB_FN [7/12]

#define DEF_INTERNAL_OPTAB_FN ( NAME,
FLAGS,
OPTAB,
TYPE )
Value:
DEF_INTERNAL_FN (NAME, FLAGS | ECF_LEAF, NULL)

◆ DEF_INTERNAL_OPTAB_FN [8/12]

#define DEF_INTERNAL_OPTAB_FN ( NAME,
FLAGS,
OPTAB,
TYPE )
Value:
DEF_INTERNAL_FN (NAME, FLAGS | ECF_LEAF, NULL)

◆ DEF_INTERNAL_OPTAB_FN [9/12]

#define DEF_INTERNAL_OPTAB_FN ( NAME,
FLAGS,
OPTAB,
TYPE )
Value:
DEF_INTERNAL_FN (NAME, FLAGS | ECF_LEAF, NULL)

◆ DEF_INTERNAL_OPTAB_FN [10/12]

#define DEF_INTERNAL_OPTAB_FN ( NAME,
FLAGS,
OPTAB,
TYPE )
Value:
DEF_INTERNAL_FN (NAME, FLAGS | ECF_LEAF, NULL)

◆ DEF_INTERNAL_OPTAB_FN [11/12]

#define DEF_INTERNAL_OPTAB_FN ( NAME,
FLAGS,
OPTAB,
TYPE )
Value:
DEF_INTERNAL_FN (NAME, FLAGS | ECF_LEAF, NULL)

◆ DEF_INTERNAL_OPTAB_FN [12/12]

#define DEF_INTERNAL_OPTAB_FN ( NAME,
FLAGS,
OPTAB,
TYPE )
Value:
DEF_INTERNAL_FN (NAME, FLAGS | ECF_LEAF, NULL)

◆ DEF_INTERNAL_SIGNED_COND_FN [1/12]

#define DEF_INTERNAL_SIGNED_COND_FN ( NAME,
FLAGS,
SELECTOR,
SIGNED_OPTAB,
UNSIGNED_OPTAB,
TYPE )
Value:
DEF_INTERNAL_SIGNED_OPTAB_FN (COND_##NAME, FLAGS, SELECTOR, \
cond_##SIGNED_OPTAB, cond_##UNSIGNED_OPTAB, \
cond_##TYPE) \
DEF_INTERNAL_SIGNED_OPTAB_FN (COND_LEN_##NAME, FLAGS, SELECTOR, \
cond_len_##SIGNED_OPTAB, \
cond_len_##UNSIGNED_OPTAB, cond_len_##TYPE)

◆ DEF_INTERNAL_SIGNED_COND_FN [2/12]

#define DEF_INTERNAL_SIGNED_COND_FN ( NAME,
FLAGS,
SELECTOR,
SIGNED_OPTAB,
UNSIGNED_OPTAB,
TYPE )
Value:
DEF_INTERNAL_SIGNED_OPTAB_FN (COND_##NAME, FLAGS, SELECTOR, \
cond_##SIGNED_OPTAB, cond_##UNSIGNED_OPTAB, \
cond_##TYPE) \
DEF_INTERNAL_SIGNED_OPTAB_FN (COND_LEN_##NAME, FLAGS, SELECTOR, \
cond_len_##SIGNED_OPTAB, \
cond_len_##UNSIGNED_OPTAB, cond_len_##TYPE)

◆ DEF_INTERNAL_SIGNED_COND_FN [3/12]

#define DEF_INTERNAL_SIGNED_COND_FN ( NAME,
FLAGS,
SELECTOR,
SIGNED_OPTAB,
UNSIGNED_OPTAB,
TYPE )
Value:
DEF_INTERNAL_SIGNED_OPTAB_FN (COND_##NAME, FLAGS, SELECTOR, \
cond_##SIGNED_OPTAB, cond_##UNSIGNED_OPTAB, \
cond_##TYPE) \
DEF_INTERNAL_SIGNED_OPTAB_FN (COND_LEN_##NAME, FLAGS, SELECTOR, \
cond_len_##SIGNED_OPTAB, \
cond_len_##UNSIGNED_OPTAB, cond_len_##TYPE)

◆ DEF_INTERNAL_SIGNED_COND_FN [4/12]

#define DEF_INTERNAL_SIGNED_COND_FN ( NAME,
FLAGS,
SELECTOR,
SIGNED_OPTAB,
UNSIGNED_OPTAB,
TYPE )
Value:
DEF_INTERNAL_SIGNED_OPTAB_FN (COND_##NAME, FLAGS, SELECTOR, \
cond_##SIGNED_OPTAB, cond_##UNSIGNED_OPTAB, \
cond_##TYPE) \
DEF_INTERNAL_SIGNED_OPTAB_FN (COND_LEN_##NAME, FLAGS, SELECTOR, \
cond_len_##SIGNED_OPTAB, \
cond_len_##UNSIGNED_OPTAB, cond_len_##TYPE)

◆ DEF_INTERNAL_SIGNED_COND_FN [5/12]

#define DEF_INTERNAL_SIGNED_COND_FN ( NAME,
FLAGS,
SELECTOR,
SIGNED_OPTAB,
UNSIGNED_OPTAB,
TYPE )
Value:
DEF_INTERNAL_SIGNED_OPTAB_FN (COND_##NAME, FLAGS, SELECTOR, \
cond_##SIGNED_OPTAB, cond_##UNSIGNED_OPTAB, \
cond_##TYPE) \
DEF_INTERNAL_SIGNED_OPTAB_FN (COND_LEN_##NAME, FLAGS, SELECTOR, \
cond_len_##SIGNED_OPTAB, \
cond_len_##UNSIGNED_OPTAB, cond_len_##TYPE)

◆ DEF_INTERNAL_SIGNED_COND_FN [6/12]

#define DEF_INTERNAL_SIGNED_COND_FN ( NAME,
FLAGS,
SELECTOR,
SIGNED_OPTAB,
UNSIGNED_OPTAB,
TYPE )
Value:
DEF_INTERNAL_SIGNED_OPTAB_FN (COND_##NAME, FLAGS, SELECTOR, \
cond_##SIGNED_OPTAB, cond_##UNSIGNED_OPTAB, \
cond_##TYPE) \
DEF_INTERNAL_SIGNED_OPTAB_FN (COND_LEN_##NAME, FLAGS, SELECTOR, \
cond_len_##SIGNED_OPTAB, \
cond_len_##UNSIGNED_OPTAB, cond_len_##TYPE)

◆ DEF_INTERNAL_SIGNED_COND_FN [7/12]

#define DEF_INTERNAL_SIGNED_COND_FN ( NAME,
FLAGS,
SELECTOR,
SIGNED_OPTAB,
UNSIGNED_OPTAB,
TYPE )
Value:
DEF_INTERNAL_SIGNED_OPTAB_FN (COND_##NAME, FLAGS, SELECTOR, \
cond_##SIGNED_OPTAB, cond_##UNSIGNED_OPTAB, \
cond_##TYPE) \
DEF_INTERNAL_SIGNED_OPTAB_FN (COND_LEN_##NAME, FLAGS, SELECTOR, \
cond_len_##SIGNED_OPTAB, \
cond_len_##UNSIGNED_OPTAB, cond_len_##TYPE)

◆ DEF_INTERNAL_SIGNED_COND_FN [8/12]

#define DEF_INTERNAL_SIGNED_COND_FN ( NAME,
FLAGS,
SELECTOR,
SIGNED_OPTAB,
UNSIGNED_OPTAB,
TYPE )
Value:
DEF_INTERNAL_SIGNED_OPTAB_FN (COND_##NAME, FLAGS, SELECTOR, \
cond_##SIGNED_OPTAB, cond_##UNSIGNED_OPTAB, \
cond_##TYPE) \
DEF_INTERNAL_SIGNED_OPTAB_FN (COND_LEN_##NAME, FLAGS, SELECTOR, \
cond_len_##SIGNED_OPTAB, \
cond_len_##UNSIGNED_OPTAB, cond_len_##TYPE)

◆ DEF_INTERNAL_SIGNED_COND_FN [9/12]

#define DEF_INTERNAL_SIGNED_COND_FN ( NAME,
FLAGS,
SELECTOR,
SIGNED_OPTAB,
UNSIGNED_OPTAB,
TYPE )
Value:
DEF_INTERNAL_SIGNED_OPTAB_FN (COND_##NAME, FLAGS, SELECTOR, \
cond_##SIGNED_OPTAB, cond_##UNSIGNED_OPTAB, \
cond_##TYPE) \
DEF_INTERNAL_SIGNED_OPTAB_FN (COND_LEN_##NAME, FLAGS, SELECTOR, \
cond_len_##SIGNED_OPTAB, \
cond_len_##UNSIGNED_OPTAB, cond_len_##TYPE)

◆ DEF_INTERNAL_SIGNED_COND_FN [10/12]

#define DEF_INTERNAL_SIGNED_COND_FN ( NAME,
FLAGS,
SELECTOR,
SIGNED_OPTAB,
UNSIGNED_OPTAB,
TYPE )
Value:
DEF_INTERNAL_SIGNED_OPTAB_FN (COND_##NAME, FLAGS, SELECTOR, \
cond_##SIGNED_OPTAB, cond_##UNSIGNED_OPTAB, \
cond_##TYPE) \
DEF_INTERNAL_SIGNED_OPTAB_FN (COND_LEN_##NAME, FLAGS, SELECTOR, \
cond_len_##SIGNED_OPTAB, \
cond_len_##UNSIGNED_OPTAB, cond_len_##TYPE)

◆ DEF_INTERNAL_SIGNED_COND_FN [11/12]

#define DEF_INTERNAL_SIGNED_COND_FN ( NAME,
FLAGS,
SELECTOR,
SIGNED_OPTAB,
UNSIGNED_OPTAB,
TYPE )
Value:
DEF_INTERNAL_SIGNED_OPTAB_FN (COND_##NAME, FLAGS, SELECTOR, \
cond_##SIGNED_OPTAB, cond_##UNSIGNED_OPTAB, \
cond_##TYPE) \
DEF_INTERNAL_SIGNED_OPTAB_FN (COND_LEN_##NAME, FLAGS, SELECTOR, \
cond_len_##SIGNED_OPTAB, \
cond_len_##UNSIGNED_OPTAB, cond_len_##TYPE)

◆ DEF_INTERNAL_SIGNED_COND_FN [12/12]

#define DEF_INTERNAL_SIGNED_COND_FN ( NAME,
... )
Value:
case IFN_COND_##NAME: \
return IFN_COND_LEN_##NAME;

◆ DEF_INTERNAL_SIGNED_OPTAB_FN [1/12]

#define DEF_INTERNAL_SIGNED_OPTAB_FN ( CODE,
FLAGS,
SELECTOR,
SIGNED_OPTAB,
UNSIGNED_OPTAB,
TYPE )
Value:
TYPE##_direct,

◆ DEF_INTERNAL_SIGNED_OPTAB_FN [2/12]

#define DEF_INTERNAL_SIGNED_OPTAB_FN ( CODE,
FLAGS,
SELECTOR,
SIGNED_OPTAB,
UNSIGNED_OPTAB,
TYPE )
Value:
case IFN_##CODE: return (TYPE_UNSIGNED (types.SELECTOR) \
? UNSIGNED_OPTAB ## _optab \
: SIGNED_OPTAB ## _optab);
TYPE_UNSIGNED
#define TYPE_UNSIGNED(NODE)
Definition tree.h:949

◆ DEF_INTERNAL_SIGNED_OPTAB_FN [3/12]

#define DEF_INTERNAL_SIGNED_OPTAB_FN ( CODE,
FLAGS,
SELECTOR,
SIGNED_OPTAB,
UNSIGNED_OPTAB,
TYPE )
Value:
case IFN_##CODE: \
{ \
optab which_optab = (TYPE_UNSIGNED (types.SELECTOR) \
? UNSIGNED_OPTAB ## _optab \
: SIGNED_OPTAB ## _optab); \
return direct_##TYPE##_optab_supported_p (which_optab, types, \
opt_type); \
}
optab
enum optab_tag optab

◆ DEF_INTERNAL_SIGNED_OPTAB_FN [4/12]

#define DEF_INTERNAL_SIGNED_OPTAB_FN ( CODE,
FLAGS,
SELECTOR,
SIGNED_OPTAB,
UNSIGNED_OPTAB,
TYPE )
Value:
static void \
expand_##CODE (internal_fn fn, gcall *stmt) \
{ \
tree_pair types = direct_internal_fn_types (fn, stmt); \
optab which_optab = direct_internal_fn_optab (fn, types); \
expand_##TYPE##_optab_fn (fn, stmt, which_optab); \
}
tree_pair
std::pair< tree, tree > tree_pair
Definition coretypes.h:384
direct_internal_fn_types
tree_pair direct_internal_fn_types(internal_fn fn, tree return_type, tree *args)
Definition internal-fn.cc:4025
direct_internal_fn_optab
optab direct_internal_fn_optab(internal_fn fn, tree_pair types)
Definition internal-fn.cc:4127

◆ DEF_INTERNAL_SIGNED_OPTAB_FN [5/12]

#define DEF_INTERNAL_SIGNED_OPTAB_FN ( NAME,
FLAGS,
SELECTOR,
SIGNED_OPTAB,
UNSIGNED_OPTAB,
TYPE )
Value:
DEF_INTERNAL_FN (NAME, FLAGS | ECF_LEAF, NULL)

◆ DEF_INTERNAL_SIGNED_OPTAB_FN [6/12]

#define DEF_INTERNAL_SIGNED_OPTAB_FN ( NAME,
FLAGS,
SELECTOR,
SIGNED_OPTAB,
UNSIGNED_OPTAB,
TYPE )
Value:
DEF_INTERNAL_FN (NAME, FLAGS | ECF_LEAF, NULL)

◆ DEF_INTERNAL_SIGNED_OPTAB_FN [7/12]

#define DEF_INTERNAL_SIGNED_OPTAB_FN ( NAME,
FLAGS,
SELECTOR,
SIGNED_OPTAB,
UNSIGNED_OPTAB,
TYPE )
Value:
DEF_INTERNAL_FN (NAME, FLAGS | ECF_LEAF, NULL)

◆ DEF_INTERNAL_SIGNED_OPTAB_FN [8/12]

#define DEF_INTERNAL_SIGNED_OPTAB_FN ( NAME,
FLAGS,
SELECTOR,
SIGNED_OPTAB,
UNSIGNED_OPTAB,
TYPE )
Value:
DEF_INTERNAL_FN (NAME, FLAGS | ECF_LEAF, NULL)

◆ DEF_INTERNAL_SIGNED_OPTAB_FN [9/12]

#define DEF_INTERNAL_SIGNED_OPTAB_FN ( NAME,
FLAGS,
SELECTOR,
SIGNED_OPTAB,
UNSIGNED_OPTAB,
TYPE )
Value:
DEF_INTERNAL_FN (NAME, FLAGS | ECF_LEAF, NULL)

◆ DEF_INTERNAL_SIGNED_OPTAB_FN [10/12]

#define DEF_INTERNAL_SIGNED_OPTAB_FN ( NAME,
FLAGS,
SELECTOR,
SIGNED_OPTAB,
UNSIGNED_OPTAB,
TYPE )
Value:
DEF_INTERNAL_FN (NAME, FLAGS | ECF_LEAF, NULL)

◆ DEF_INTERNAL_SIGNED_OPTAB_FN [11/12]

#define DEF_INTERNAL_SIGNED_OPTAB_FN ( NAME,
FLAGS,
SELECTOR,
SIGNED_OPTAB,
UNSIGNED_OPTAB,
TYPE )
Value:
DEF_INTERNAL_FN (NAME, FLAGS | ECF_LEAF, NULL)

◆ DEF_INTERNAL_SIGNED_OPTAB_FN [12/12]

#define DEF_INTERNAL_SIGNED_OPTAB_FN ( NAME,
FLAGS,
SELECTOR,
SIGNED_OPTAB,
UNSIGNED_OPTAB,
TYPE )
Value:
DEF_INTERNAL_FN (NAME, FLAGS | ECF_LEAF, NULL)

◆ DEF_INTERNAL_WIDENING_OPTAB_FN [1/12]

#define DEF_INTERNAL_WIDENING_OPTAB_FN ( NAME,
F,
S,
SO,
UO,
T )
Value:
case IFN_##NAME: \
*lo = internal_fn (IFN_##NAME##_LO); \
*hi = internal_fn (IFN_##NAME##_HI); \
break;

◆ DEF_INTERNAL_WIDENING_OPTAB_FN [2/12]

#define DEF_INTERNAL_WIDENING_OPTAB_FN ( NAME,
F,
S,
SO,
UO,
T )
Value:
case IFN_##NAME: \
*even = internal_fn (IFN_##NAME##_EVEN); \
*odd = internal_fn (IFN_##NAME##_ODD); \
break;

◆ DEF_INTERNAL_WIDENING_OPTAB_FN [3/12]

#define DEF_INTERNAL_WIDENING_OPTAB_FN ( NAME,
F,
S,
SO,
UO,
T )
Value:
case IFN_##NAME: \
case IFN_##NAME##_HI: \
case IFN_##NAME##_LO: \
case IFN_##NAME##_EVEN: \
case IFN_##NAME##_ODD: \
return true;

◆ DEF_INTERNAL_WIDENING_OPTAB_FN [4/12]

#define DEF_INTERNAL_WIDENING_OPTAB_FN ( NAME,
FLAGS,
SELECTOR,
SOPTAB,
UOPTAB,
TYPE )
Value:
DEF_INTERNAL_SIGNED_OPTAB_FN (NAME, FLAGS, SELECTOR, SOPTAB, UOPTAB, TYPE) \
DEF_INTERNAL_SIGNED_OPTAB_FN (NAME ## _LO, FLAGS, SELECTOR, SOPTAB##_lo, UOPTAB##_lo, TYPE) \
DEF_INTERNAL_SIGNED_OPTAB_FN (NAME ## _HI, FLAGS, SELECTOR, SOPTAB##_hi, UOPTAB##_hi, TYPE) \
DEF_INTERNAL_SIGNED_OPTAB_FN (NAME ## _EVEN, FLAGS, SELECTOR, SOPTAB##_even, UOPTAB##_even, TYPE) \
DEF_INTERNAL_SIGNED_OPTAB_FN (NAME ## _ODD, FLAGS, SELECTOR, SOPTAB##_odd, UOPTAB##_odd, TYPE)

◆ DEF_INTERNAL_WIDENING_OPTAB_FN [5/12]

#define DEF_INTERNAL_WIDENING_OPTAB_FN ( NAME,
FLAGS,
SELECTOR,
SOPTAB,
UOPTAB,
TYPE )
Value:
DEF_INTERNAL_SIGNED_OPTAB_FN (NAME, FLAGS, SELECTOR, SOPTAB, UOPTAB, TYPE) \
DEF_INTERNAL_SIGNED_OPTAB_FN (NAME ## _LO, FLAGS, SELECTOR, SOPTAB##_lo, UOPTAB##_lo, TYPE) \
DEF_INTERNAL_SIGNED_OPTAB_FN (NAME ## _HI, FLAGS, SELECTOR, SOPTAB##_hi, UOPTAB##_hi, TYPE) \
DEF_INTERNAL_SIGNED_OPTAB_FN (NAME ## _EVEN, FLAGS, SELECTOR, SOPTAB##_even, UOPTAB##_even, TYPE) \
DEF_INTERNAL_SIGNED_OPTAB_FN (NAME ## _ODD, FLAGS, SELECTOR, SOPTAB##_odd, UOPTAB##_odd, TYPE)

◆ DEF_INTERNAL_WIDENING_OPTAB_FN [6/12]

#define DEF_INTERNAL_WIDENING_OPTAB_FN ( NAME,
FLAGS,
SELECTOR,
SOPTAB,
UOPTAB,
TYPE )
Value:
DEF_INTERNAL_SIGNED_OPTAB_FN (NAME, FLAGS, SELECTOR, SOPTAB, UOPTAB, TYPE) \
DEF_INTERNAL_SIGNED_OPTAB_FN (NAME ## _LO, FLAGS, SELECTOR, SOPTAB##_lo, UOPTAB##_lo, TYPE) \
DEF_INTERNAL_SIGNED_OPTAB_FN (NAME ## _HI, FLAGS, SELECTOR, SOPTAB##_hi, UOPTAB##_hi, TYPE) \
DEF_INTERNAL_SIGNED_OPTAB_FN (NAME ## _EVEN, FLAGS, SELECTOR, SOPTAB##_even, UOPTAB##_even, TYPE) \
DEF_INTERNAL_SIGNED_OPTAB_FN (NAME ## _ODD, FLAGS, SELECTOR, SOPTAB##_odd, UOPTAB##_odd, TYPE)

◆ DEF_INTERNAL_WIDENING_OPTAB_FN [7/12]

#define DEF_INTERNAL_WIDENING_OPTAB_FN ( NAME,
FLAGS,
SELECTOR,
SOPTAB,
UOPTAB,
TYPE )
Value:
DEF_INTERNAL_SIGNED_OPTAB_FN (NAME, FLAGS, SELECTOR, SOPTAB, UOPTAB, TYPE) \
DEF_INTERNAL_SIGNED_OPTAB_FN (NAME ## _LO, FLAGS, SELECTOR, SOPTAB##_lo, UOPTAB##_lo, TYPE) \
DEF_INTERNAL_SIGNED_OPTAB_FN (NAME ## _HI, FLAGS, SELECTOR, SOPTAB##_hi, UOPTAB##_hi, TYPE) \
DEF_INTERNAL_SIGNED_OPTAB_FN (NAME ## _EVEN, FLAGS, SELECTOR, SOPTAB##_even, UOPTAB##_even, TYPE) \
DEF_INTERNAL_SIGNED_OPTAB_FN (NAME ## _ODD, FLAGS, SELECTOR, SOPTAB##_odd, UOPTAB##_odd, TYPE)

◆ DEF_INTERNAL_WIDENING_OPTAB_FN [8/12]

#define DEF_INTERNAL_WIDENING_OPTAB_FN ( NAME,
FLAGS,
SELECTOR,
SOPTAB,
UOPTAB,
TYPE )
Value:
DEF_INTERNAL_SIGNED_OPTAB_FN (NAME, FLAGS, SELECTOR, SOPTAB, UOPTAB, TYPE) \
DEF_INTERNAL_SIGNED_OPTAB_FN (NAME ## _LO, FLAGS, SELECTOR, SOPTAB##_lo, UOPTAB##_lo, TYPE) \
DEF_INTERNAL_SIGNED_OPTAB_FN (NAME ## _HI, FLAGS, SELECTOR, SOPTAB##_hi, UOPTAB##_hi, TYPE) \
DEF_INTERNAL_SIGNED_OPTAB_FN (NAME ## _EVEN, FLAGS, SELECTOR, SOPTAB##_even, UOPTAB##_even, TYPE) \
DEF_INTERNAL_SIGNED_OPTAB_FN (NAME ## _ODD, FLAGS, SELECTOR, SOPTAB##_odd, UOPTAB##_odd, TYPE)

◆ DEF_INTERNAL_WIDENING_OPTAB_FN [9/12]

#define DEF_INTERNAL_WIDENING_OPTAB_FN ( NAME,
FLAGS,
SELECTOR,
SOPTAB,
UOPTAB,
TYPE )
Value:
DEF_INTERNAL_SIGNED_OPTAB_FN (NAME, FLAGS, SELECTOR, SOPTAB, UOPTAB, TYPE) \
DEF_INTERNAL_SIGNED_OPTAB_FN (NAME ## _LO, FLAGS, SELECTOR, SOPTAB##_lo, UOPTAB##_lo, TYPE) \
DEF_INTERNAL_SIGNED_OPTAB_FN (NAME ## _HI, FLAGS, SELECTOR, SOPTAB##_hi, UOPTAB##_hi, TYPE) \
DEF_INTERNAL_SIGNED_OPTAB_FN (NAME ## _EVEN, FLAGS, SELECTOR, SOPTAB##_even, UOPTAB##_even, TYPE) \
DEF_INTERNAL_SIGNED_OPTAB_FN (NAME ## _ODD, FLAGS, SELECTOR, SOPTAB##_odd, UOPTAB##_odd, TYPE)

◆ DEF_INTERNAL_WIDENING_OPTAB_FN [10/12]

#define DEF_INTERNAL_WIDENING_OPTAB_FN ( NAME,
FLAGS,
SELECTOR,
SOPTAB,
UOPTAB,
TYPE )
Value:
DEF_INTERNAL_SIGNED_OPTAB_FN (NAME, FLAGS, SELECTOR, SOPTAB, UOPTAB, TYPE) \
DEF_INTERNAL_SIGNED_OPTAB_FN (NAME ## _LO, FLAGS, SELECTOR, SOPTAB##_lo, UOPTAB##_lo, TYPE) \
DEF_INTERNAL_SIGNED_OPTAB_FN (NAME ## _HI, FLAGS, SELECTOR, SOPTAB##_hi, UOPTAB##_hi, TYPE) \
DEF_INTERNAL_SIGNED_OPTAB_FN (NAME ## _EVEN, FLAGS, SELECTOR, SOPTAB##_even, UOPTAB##_even, TYPE) \
DEF_INTERNAL_SIGNED_OPTAB_FN (NAME ## _ODD, FLAGS, SELECTOR, SOPTAB##_odd, UOPTAB##_odd, TYPE)

◆ DEF_INTERNAL_WIDENING_OPTAB_FN [11/12]

#define DEF_INTERNAL_WIDENING_OPTAB_FN ( NAME,
FLAGS,
SELECTOR,
SOPTAB,
UOPTAB,
TYPE )
Value:
DEF_INTERNAL_SIGNED_OPTAB_FN (NAME, FLAGS, SELECTOR, SOPTAB, UOPTAB, TYPE) \
DEF_INTERNAL_SIGNED_OPTAB_FN (NAME ## _LO, FLAGS, SELECTOR, SOPTAB##_lo, UOPTAB##_lo, TYPE) \
DEF_INTERNAL_SIGNED_OPTAB_FN (NAME ## _HI, FLAGS, SELECTOR, SOPTAB##_hi, UOPTAB##_hi, TYPE) \
DEF_INTERNAL_SIGNED_OPTAB_FN (NAME ## _EVEN, FLAGS, SELECTOR, SOPTAB##_even, UOPTAB##_even, TYPE) \
DEF_INTERNAL_SIGNED_OPTAB_FN (NAME ## _ODD, FLAGS, SELECTOR, SOPTAB##_odd, UOPTAB##_odd, TYPE)

◆ DEF_INTERNAL_WIDENING_OPTAB_FN [12/12]

#define DEF_INTERNAL_WIDENING_OPTAB_FN ( NAME,
FLAGS,
SELECTOR,
SOPTAB,
UOPTAB,
TYPE )
Value:
DEF_INTERNAL_SIGNED_OPTAB_FN (NAME, FLAGS, SELECTOR, SOPTAB, UOPTAB, TYPE) \
DEF_INTERNAL_SIGNED_OPTAB_FN (NAME ## _LO, FLAGS, SELECTOR, SOPTAB##_lo, UOPTAB##_lo, TYPE) \
DEF_INTERNAL_SIGNED_OPTAB_FN (NAME ## _HI, FLAGS, SELECTOR, SOPTAB##_hi, UOPTAB##_hi, TYPE) \
DEF_INTERNAL_SIGNED_OPTAB_FN (NAME ## _EVEN, FLAGS, SELECTOR, SOPTAB##_even, UOPTAB##_even, TYPE) \
DEF_INTERNAL_SIGNED_OPTAB_FN (NAME ## _ODD, FLAGS, SELECTOR, SOPTAB##_odd, UOPTAB##_odd, TYPE)

◆ direct_binary_optab_supported_p

#define direct_binary_optab_supported_p   direct_optab_supported_p

◆ direct_check_ptrs_optab_supported_p

#define direct_check_ptrs_optab_supported_p   direct_optab_supported_p

◆ direct_cond_binary_optab_supported_p

#define direct_cond_binary_optab_supported_p   direct_optab_supported_p

◆ direct_cond_len_binary_optab_supported_p

#define direct_cond_len_binary_optab_supported_p   direct_optab_supported_p

◆ direct_cond_len_ternary_optab_supported_p

#define direct_cond_len_ternary_optab_supported_p   direct_optab_supported_p

◆ direct_cond_len_unary_optab_supported_p

#define direct_cond_len_unary_optab_supported_p   direct_optab_supported_p

◆ direct_cond_ternary_optab_supported_p

#define direct_cond_ternary_optab_supported_p   direct_optab_supported_p

◆ direct_cond_unary_optab_supported_p

#define direct_cond_unary_optab_supported_p   direct_optab_supported_p

◆ direct_fold_extract_optab_supported_p

#define direct_fold_extract_optab_supported_p   direct_optab_supported_p

◆ direct_fold_left_optab_supported_p

#define direct_fold_left_optab_supported_p   direct_optab_supported_p

◆ direct_fold_len_extract_optab_supported_p

#define direct_fold_len_extract_optab_supported_p   direct_optab_supported_p

◆ direct_gather_load_optab_supported_p

#define direct_gather_load_optab_supported_p   convert_optab_supported_p

◆ direct_len_load_optab_supported_p

#define direct_len_load_optab_supported_p   direct_optab_supported_p

◆ direct_len_store_optab_supported_p

#define direct_len_store_optab_supported_p   direct_optab_supported_p

◆ direct_load_lanes_optab_supported_p

#define direct_load_lanes_optab_supported_p   multi_vector_optab_supported_p

◆ direct_mask_fold_left_optab_supported_p

#define direct_mask_fold_left_optab_supported_p   direct_optab_supported_p

◆ direct_mask_len_fold_left_optab_supported_p

#define direct_mask_len_fold_left_optab_supported_p   direct_optab_supported_p

◆ direct_mask_len_load_optab_supported_p

#define direct_mask_len_load_optab_supported_p   convert_optab_supported_p

◆ direct_mask_len_store_optab_supported_p

#define direct_mask_len_store_optab_supported_p   convert_optab_supported_p

◆ direct_mask_load_lanes_optab_supported_p

#define direct_mask_load_lanes_optab_supported_p   multi_vector_optab_supported_p

◆ direct_mask_load_optab_supported_p

#define direct_mask_load_optab_supported_p   convert_optab_supported_p

◆ direct_mask_store_lanes_optab_supported_p

#define direct_mask_store_lanes_optab_supported_p   multi_vector_optab_supported_p

◆ direct_mask_store_optab_supported_p

#define direct_mask_store_optab_supported_p   convert_optab_supported_p

◆ direct_scatter_store_optab_supported_p

#define direct_scatter_store_optab_supported_p   convert_optab_supported_p

◆ direct_store_lanes_optab_supported_p

#define direct_store_lanes_optab_supported_p   multi_vector_optab_supported_p

◆ direct_ternary_optab_supported_p

#define direct_ternary_optab_supported_p   direct_optab_supported_p

◆ direct_unary_convert_optab_supported_p

#define direct_unary_convert_optab_supported_p   convert_optab_supported_p

◆ direct_unary_optab_supported_p

#define direct_unary_optab_supported_p   direct_optab_supported_p

◆ direct_vec_cond_mask_optab_supported_p

#define direct_vec_cond_mask_optab_supported_p   convert_optab_supported_p

◆ direct_vec_cond_optab_supported_p

#define direct_vec_cond_optab_supported_p   convert_optab_supported_p

◆ direct_vec_extract_optab_supported_p

#define direct_vec_extract_optab_supported_p   convert_optab_supported_p

◆ direct_vec_set_optab_supported_p

#define direct_vec_set_optab_supported_p   direct_optab_supported_p

◆ direct_while_optab_supported_p

#define direct_while_optab_supported_p   convert_optab_supported_p

◆ expand_binary_optab_fn

#define expand_binary_optab_fn ( FN,
STMT,
OPTAB )
Value:
expand_direct_optab_fn (FN, STMT, OPTAB, 2)
expand_direct_optab_fn
static void expand_direct_optab_fn(internal_fn fn, gcall *stmt, direct_optab optab, unsigned int nargs)
Definition internal-fn.cc:3901

◆ expand_check_ptrs_optab_fn

#define expand_check_ptrs_optab_fn ( FN,
STMT,
OPTAB )
Value:
expand_direct_optab_fn (FN, STMT, OPTAB, 4)

◆ expand_cond_binary_optab_fn

#define expand_cond_binary_optab_fn ( FN,
STMT,
OPTAB )
Value:
expand_direct_optab_fn (FN, STMT, OPTAB, 4)

◆ expand_cond_len_binary_optab_fn

#define expand_cond_len_binary_optab_fn ( FN,
STMT,
OPTAB )
Value:
expand_direct_optab_fn (FN, STMT, OPTAB, 6)

◆ expand_cond_len_ternary_optab_fn

#define expand_cond_len_ternary_optab_fn ( FN,
STMT,
OPTAB )
Value:
expand_direct_optab_fn (FN, STMT, OPTAB, 7)

◆ expand_cond_len_unary_optab_fn

#define expand_cond_len_unary_optab_fn ( FN,
STMT,
OPTAB )
Value:
expand_direct_optab_fn (FN, STMT, OPTAB, 5)

◆ expand_cond_ternary_optab_fn

#define expand_cond_ternary_optab_fn ( FN,
STMT,
OPTAB )
Value:
expand_direct_optab_fn (FN, STMT, OPTAB, 5)

◆ expand_cond_unary_optab_fn

#define expand_cond_unary_optab_fn ( FN,
STMT,
OPTAB )
Value:
expand_direct_optab_fn (FN, STMT, OPTAB, 3)

◆ expand_fold_extract_optab_fn

#define expand_fold_extract_optab_fn ( FN,
STMT,
OPTAB )
Value:
expand_direct_optab_fn (FN, STMT, OPTAB, 3)

◆ expand_fold_left_optab_fn

#define expand_fold_left_optab_fn ( FN,
STMT,
OPTAB )
Value:
expand_direct_optab_fn (FN, STMT, OPTAB, 2)

◆ expand_fold_len_extract_optab_fn

#define expand_fold_len_extract_optab_fn ( FN,
STMT,
OPTAB )
Value:
expand_direct_optab_fn (FN, STMT, OPTAB, 5)

◆ expand_len_load_optab_fn

#define expand_len_load_optab_fn   expand_partial_load_optab_fn

◆ expand_len_store_optab_fn

#define expand_len_store_optab_fn   expand_partial_store_optab_fn

◆ expand_mask_fold_left_optab_fn

#define expand_mask_fold_left_optab_fn ( FN,
STMT,
OPTAB )
Value:
expand_direct_optab_fn (FN, STMT, OPTAB, 3)

◆ expand_mask_len_fold_left_optab_fn

#define expand_mask_len_fold_left_optab_fn ( FN,
STMT,
OPTAB )
Value:
expand_direct_optab_fn (FN, STMT, OPTAB, 5)

◆ expand_mask_len_load_optab_fn

#define expand_mask_len_load_optab_fn   expand_partial_load_optab_fn

◆ expand_mask_len_store_optab_fn

#define expand_mask_len_store_optab_fn   expand_partial_store_optab_fn

◆ expand_mask_load_lanes_optab_fn

#define expand_mask_load_lanes_optab_fn   expand_mask_load_optab_fn

◆ expand_mask_load_optab_fn

#define expand_mask_load_optab_fn   expand_partial_load_optab_fn

◆ expand_mask_store_lanes_optab_fn

#define expand_mask_store_lanes_optab_fn   expand_mask_store_optab_fn

◆ expand_mask_store_optab_fn

#define expand_mask_store_optab_fn   expand_partial_store_optab_fn

◆ expand_ternary_optab_fn

#define expand_ternary_optab_fn ( FN,
STMT,
OPTAB )
Value:
expand_direct_optab_fn (FN, STMT, OPTAB, 3)

◆ expand_unary_convert_optab_fn

#define expand_unary_convert_optab_fn ( FN,
STMT,
OPTAB )
Value:
expand_convert_optab_fn (FN, STMT, OPTAB, 1)
expand_convert_optab_fn
static void expand_convert_optab_fn(internal_fn fn, gcall *stmt, convert_optab optab, unsigned int nargs)
Definition internal-fn.cc:3955
Expanders for optabs that can use expand_convert_optab_fn.

◆ expand_unary_optab_fn

#define expand_unary_optab_fn ( FN,
STMT,
OPTAB )
Value:
expand_direct_optab_fn (FN, STMT, OPTAB, 1)
Expanders for optabs that can use expand_direct_optab_fn.

Referenced by expand_CLRSB(), expand_CLZ(), expand_CTZ(), expand_FFS(), expand_PARITY(), and expand_POPCOUNT().

◆ expand_vec_extract_optab_fn

#define expand_vec_extract_optab_fn ( FN,
STMT,
OPTAB )
Value:
expand_convert_optab_fn (FN, STMT, OPTAB, 2)

◆ fold_extract_direct

#define fold_extract_direct   { 2, 2, false }

◆ fold_left_direct

#define fold_left_direct   { 1, 1, false }

◆ fold_len_extract_direct

#define fold_len_extract_direct   { 2, 2, false }

◆ FOR_EACH_CODE_MAPPING

#define FOR_EACH_CODE_MAPPING ( T)
Value:
T (PLUS_EXPR, ADD) \
T (MINUS_EXPR, SUB) \
T (MULT_EXPR, MUL) \
T (TRUNC_DIV_EXPR, DIV) \
T (TRUNC_MOD_EXPR, MOD) \
T (RDIV_EXPR, RDIV) \
T (MIN_EXPR, MIN) \
T (MAX_EXPR, MAX) \
T (BIT_AND_EXPR, AND) \
T (BIT_IOR_EXPR, IOR) \
T (BIT_XOR_EXPR, XOR) \
T (LSHIFT_EXPR, SHL) \
T (RSHIFT_EXPR, SHR) \
T (NEGATE_EXPR, NEG)
T
static struct token T
Definition gengtype-parse.cc:45
RDIV
#define RDIV(X, Y)
Definition profile-count.h:75
MIN
#define MIN(X, Y)
Definition system.h:392
MAX
#define MAX(X, Y)
Definition system.h:393
Invoke T(CODE, SUFFIX) for each conditional function IFN_COND_##SUFFIX
that maps to a tree code CODE.  There is also an IFN_COND_LEN_##SUFFIX
for each such IFN_COND_##SUFFIX.

Referenced by conditional_internal_fn_code(), get_conditional_internal_fn(), and get_conditional_len_internal_fn().

◆ FOR_EACH_COND_FN_PAIR

#define FOR_EACH_COND_FN_PAIR ( T)
Value:
T (FMAX) \
T (FMIN) \
T (FMA) \
T (FMS) \
T (FNMA) \
T (FNMS)
Invoke T(IFN) for each internal function IFN that also has an
IFN_COND_* form.

Referenced by get_conditional_internal_fn(), and get_unconditional_internal_fn().

◆ gather_load_direct

#define gather_load_direct   { 3, 1, false }

◆ INIT_PATTERN_VALUE

#define INIT_PATTERN_VALUE   0xFE 
Expand the IFN_DEFERRED_INIT function:
LHS = DEFERRED_INIT (SIZE of the DECL, INIT_TYPE, NAME of the DECL);

Initialize the LHS with zero/pattern according to its second argument
INIT_TYPE:
if INIT_TYPE is AUTO_INIT_ZERO, use zeroes to initialize;
if INIT_TYPE is AUTO_INIT_PATTERN, use 0xFE byte-repeatable pattern
  to initialize;
The LHS variable is initialized including paddings.
The reasons to choose 0xFE for pattern initialization are:
  1. It is a non-canonical virtual address on x86_64, and at the
     high end of the i386 kernel address space.
  2. It is a very large float value (-1.694739530317379e+38).
  3. It is also an unusual number for integers.

Referenced by expand_DEFERRED_INIT().

◆ len_load_direct

#define len_load_direct   { -1, -1, false }

◆ len_store_direct

#define len_store_direct   { 3, 3, false }

◆ load_lanes_direct

#define load_lanes_direct   { -1, -1, false }

◆ mask_fold_left_direct

#define mask_fold_left_direct   { 1, 1, false }

◆ mask_len_fold_left_direct

#define mask_len_fold_left_direct   { 1, 1, false }

◆ mask_len_load_direct

#define mask_len_load_direct   { -1, 4, false }

◆ mask_len_store_direct

#define mask_len_store_direct   { 4, 5, false }

◆ mask_load_direct

#define mask_load_direct   { -1, 2, false }

◆ mask_load_lanes_direct

#define mask_load_lanes_direct   { -1, -1, false }

◆ mask_store_direct

#define mask_store_direct   { 3, 2, false }

◆ mask_store_lanes_direct

#define mask_store_lanes_direct   { 0, 0, false }

◆ not_direct

#define not_direct   { -2, -2, false } 
Create static initializers for the information returned by
direct_internal_fn.

◆ scatter_store_direct

#define scatter_store_direct   { 3, 1, false }

◆ store_lanes_direct

#define store_lanes_direct   { 0, 0, false }

◆ ternary_direct

#define ternary_direct   { 0, 0, true }

◆ unary_convert_direct

#define unary_convert_direct   { -1, 0, true }

◆ unary_direct

#define unary_direct   { 0, 0, true }

◆ vec_cond_direct

#define vec_cond_direct   { 2, 0, false }

◆ vec_cond_mask_direct

#define vec_cond_mask_direct   { 1, 0, false }

◆ vec_cond_mask_len_direct

#define vec_cond_mask_len_direct   { 1, 1, false }

◆ vec_extract_direct

#define vec_extract_direct   { 0, -1, false }

◆ vec_set_direct

#define vec_set_direct   { 3, 3, false }

◆ while_direct

#define while_direct   { 0, 2, false }

Function Documentation

◆ add_mask_and_len_args()

static unsigned int add_mask_and_len_args ( expand_operand * ops,
unsigned int opno,
gcall * stmt )
static 
Add mask and len arguments according to the STMT.

References create_convert_operand_from(), create_input_operand(), expand_binop(), expand_normal(), GEN_INT, GET_MODE_PRECISION(), gimple_call_arg(), gimple_call_internal_fn(), HOST_WIDE_INT_1U, internal_fn_len_index(), internal_fn_mask_index(), mask_rtx(), NULL_RTX, OPTAB_WIDEN, SCALAR_INT_MODE_P, poly_int< N, C >::to_constant(), TREE_TYPE, TYPE_MODE, TYPE_UNSIGNED, TYPE_VECTOR_SUBPARTS(), and VECTOR_BOOLEAN_TYPE_P.

Referenced by expand_gather_load_optab_fn(), expand_partial_load_optab_fn(), expand_partial_store_optab_fn(), and expand_scatter_store_optab_fn().

◆ assign_call_lhs()

static void assign_call_lhs ( tree lhs,
rtx lhs_rtx,
expand_operand * op )
static 
Move the result of an expanded instruction into the lhs of a gimple call.
LHS is the lhs of the call, LHS_RTX is its expanded form, and OP is the
result of the expanded instruction.  OP should have been set up by
create_call_lhs_operand.

References convert_move(), convert_to_mode(), emit_move_insn(), gcc_checking_assert, GET_CODE, GET_MODE, INTEGRAL_TYPE_P, rtx_equal_p(), SUBREG_PROMOTED_SIGN, SUBREG_PROMOTED_VAR_P, SUBREG_REG, TREE_TYPE, and expand_operand::value.

Referenced by expand_fn_using_insn(), expand_gather_load_optab_fn(), expand_GOMP_SIMT_ENTER_ALLOC(), expand_GOMP_SIMT_LAST_LANE(), expand_GOMP_SIMT_ORDERED_PRED(), expand_GOMP_SIMT_VOTE_ANY(), expand_GOMP_SIMT_XCHG_BFLY(), expand_GOMP_SIMT_XCHG_IDX(), expand_load_lanes_optab_fn(), expand_partial_load_optab_fn(), expand_RAWMEMCHR(), expand_SPACESHIP(), expand_vec_cond_mask_optab_fn(), expand_vec_cond_optab_fn(), and expand_while_optab_fn().

◆ associative_binary_fn_p()

bool associative_binary_fn_p ( internal_fn fn) 
Return true if FN is an associative binary operation.

Referenced by associative_binary_op_p().

◆ can_interpret_as_conditional_op_p()

bool can_interpret_as_conditional_op_p ( gimple * stmt,
tree * cond_out,
tree_code * code_out,
tree(&) ops[3],
tree * else_out,
tree * len,
tree * bias ) 
Return true if STMT can be interpreted as a conditional tree code
operation of the form:

  LHS = COND ? OP (RHS1, ...) : ELSE;

operating elementwise if the operands are vectors.  This includes
the case of an all-true COND, so that the operation always happens.

There is an alternative approach to interpret the STMT when the operands
are vectors which is the operation predicated by both conditional mask
and loop control length, the equivalent C code:

  for (int i = 0; i < NUNTIS; i++)
   {
     if (i < LEN + BIAS && COND[i])
       LHS[i] = A[i] CODE B[i];
     else
       LHS[i] = ELSE[i];
   }

When returning true, set:

- *COND_OUT to the condition COND, or to NULL_TREE if the condition
  is known to be all-true
- *CODE_OUT to the tree code
- OPS[I] to operand I of *CODE_OUT
- *ELSE_OUT to the fallback value ELSE, or to NULL_TREE if the
  condition is known to be all true.
- *LEN to the len argument if it COND_LEN_* operations or to NULL_TREE.
- *BIAS to the bias argument if it COND_LEN_* operations or to NULL_TREE.

References separate_ops::code, conditional_internal_fn_code(), dyn_cast(), gimple_assign_rhs1(), gimple_assign_rhs2(), gimple_assign_rhs3(), gimple_assign_rhs_code(), gimple_call_arg(), gimple_call_internal_fn(), gimple_call_internal_p(), gimple_call_num_args(), i, integer_truep(), internal_fn_len_index(), and NULL_TREE.

Referenced by convert_mult_to_fma(), and convert_mult_to_fma_1().

◆ can_widen_mult_without_libcall()

static bool can_widen_mult_without_libcall ( scalar_int_mode wmode,
scalar_int_mode mode,
rtx op0,
rtx op1,
bool uns )
static 
Return true if UNS WIDEN_MULT_EXPR with result mode WMODE and operand
mode MODE can be expanded without using a libcall.

References CONSTANT_P, convert_modes(), delete_insns_since(), expand_mult(), find_widening_optab_handler, gen_raw_REG(), get_last_insn(), last, LAST_VIRTUAL_REGISTER, expand_operand::mode, and NULL_RTX.

Referenced by expand_mul_overflow().

◆ commutative_binary_fn_p()

bool commutative_binary_fn_p ( internal_fn fn) 
Return true if FN is a binary operation and if FN is commutative.

Referenced by commutative_binary_op_p(), and first_commutative_argument().

◆ commutative_ternary_fn_p()

bool commutative_ternary_fn_p ( internal_fn fn) 
Return true if FN is a ternary operation and if its first two arguments
are commutative.

Referenced by commutative_ternary_op_p(), and first_commutative_argument().

◆ conditional_internal_fn_code()

tree_code conditional_internal_fn_code ( internal_fn ifn) 
If IFN implements the conditional form of a tree code, return that
tree code, otherwise return ERROR_MARK.

References CASE, and FOR_EACH_CODE_MAPPING.

Referenced by can_interpret_as_conditional_op_p(), check_reduction_path(), internal_fn_mask_index(), try_conditional_simplification(), vect_transform_loop(), vect_transform_reduction(), vectorizable_reduction(), and vectorize_fold_left_reduction().

◆ contains_call_div_mod()

static bool contains_call_div_mod ( rtx_insn * insn)
static 
Helper for expand_DIVMOD.  Return true if the sequence starting with
INSN contains any call insns or insns with {,U}{DIV,MOD} rtxes.

References CALL_P, FOR_EACH_SUBRTX, GET_CODE, INSN_P, NEXT_INSN(), and PATTERN().

Referenced by expand_DIVMOD().

◆ convert_optab_supported_p()

static bool convert_optab_supported_p ( convert_optab optab,
tree_pair types,
optimization_type opt_type )
static 
Return true if OPTAB is supported for TYPES, where the first type
is the destination and the second type is the source.  Used for
convert optabs.

References convert_optab_handler(), and TYPE_MODE.

◆ create_call_lhs_operand()

static void create_call_lhs_operand ( expand_operand * op,
rtx lhs_rtx,
machine_mode mode )
static 
Like create_output_operand, but for callers that will use
assign_call_lhs afterwards.

References create_output_operand(), GET_CODE, NULL_RTX, and SUBREG_PROMOTED_VAR_P.

Referenced by expand_fn_using_insn(), expand_gather_load_optab_fn(), expand_GOMP_SIMT_ENTER_ALLOC(), expand_GOMP_SIMT_LAST_LANE(), expand_GOMP_SIMT_ORDERED_PRED(), expand_GOMP_SIMT_VOTE_ANY(), expand_GOMP_SIMT_XCHG_BFLY(), expand_GOMP_SIMT_XCHG_IDX(), expand_load_lanes_optab_fn(), expand_partial_load_optab_fn(), expand_RAWMEMCHR(), expand_SPACESHIP(), expand_vec_cond_mask_optab_fn(), expand_vec_cond_optab_fn(), and expand_while_optab_fn().

◆ direct_internal_fn_optab() [1/2]

static optab direct_internal_fn_optab ( internal_fn fn)
static 
Return the optab used by internal function FN.   
Internal functions.
   Copyright (C) 2011-2024 Free Software Foundation, Inc.

This file is part of GCC.

GCC is free software; you can redistribute it and/or modify it under
the terms of the GNU General Public License as published by the Free
Software Foundation; either version 3, or (at your option) any later
version.

GCC is distributed in the hope that it will be useful, but WITHOUT ANY
WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
for more details.

You should have received a copy of the GNU General Public License
along with GCC; see the file COPYING3.  If not see
<http://www.gnu.org/licenses/>.   
This file specifies a list of internal "functions".  These functions
differ from built-in functions in that they have no linkage and cannot
be called directly by the user.  They represent operations that are only
synthesised by GCC itself.

Internal functions are used instead of tree codes if the operation
and its operands are more naturally represented as a GIMPLE_CALL
than a GIMPLE_ASSIGN.

Each entry in this file has one of the forms:

  DEF_INTERNAL_FN (NAME, FLAGS, FNSPEC)
  DEF_INTERNAL_OPTAB_FN (NAME, FLAGS, OPTAB, TYPE)
  DEF_INTERNAL_SIGNED_OPTAB_FN (NAME, FLAGS, SELECTOR, SIGNED_OPTAB,
                           UNSIGNED_OPTAB, TYPE)
  DEF_INTERNAL_FLT_FN (NAME, FLAGS, OPTAB, TYPE)
  DEF_INTERNAL_FLT_FLOATN_FN (NAME, FLAGS, OPTAB, TYPE)
  DEF_INTERNAL_INT_FN (NAME, FLAGS, OPTAB, TYPE)
  DEF_INTERNAL_INT_EXT_FN (NAME, FLAGS, OPTAB, TYPE)
  DEF_INTERNAL_COND_FN (NAME, FLAGS, OPTAB, TYPE)
  DEF_INTERNAL_SIGNED_COND_FN (NAME, FLAGS, OPTAB, TYPE)
  DEF_INTERNAL_WIDENING_OPTAB_FN (NAME, FLAGS, SELECTOR, SOPTAB, UOPTAB,
                             TYPE)

where NAME is the name of the function, FLAGS is a set of
ECF_* flags and FNSPEC is a string describing functions fnspec.

DEF_INTERNAL_OPTAB_FN defines an internal function that maps to a
direct optab.  The function should only be called with a given
set of types if the associated optab is available for the modes
of those types.  OPTAB says what optab to use (without the trailing
"_optab") and TYPE categorizes the optab based on its inputs and
outputs.  The possible types of optab are:

- mask_load: currently just maskload
- load_lanes: currently just vec_load_lanes
- mask_load_lanes: currently just vec_mask_load_lanes
- mask_len_load_lanes: currently just vec_mask_len_load_lanes
- gather_load: used for {mask_,mask_len_,}gather_load
- len_load: currently just len_load
- mask_len_load: currently just mask_len_load

- mask_store: currently just maskstore
- store_lanes: currently just vec_store_lanes
- mask_store_lanes: currently just vec_mask_store_lanes
- mask_len_store_lanes: currently just vec_mask_len_store_lanes
- scatter_store: used for {mask_,mask_len_,}scatter_store
- len_store: currently just len_store
- mask_len_store: currently just mask_len_store

- unary: a normal unary optab, such as vec_reverse_<mode>
- binary: a normal binary optab, such as vec_interleave_lo_<mode>
- ternary: a normal ternary optab, such as fma<mode>4

- unary_convert: a single-input conversion optab, such as
  lround<srcmode><dstmode>2.

- cond_binary: a conditional binary optab, such as cond_add<mode>
- cond_unary: a conditional unary optab, such as cond_neg<mode>
- cond_ternary: a conditional ternary optab, such as cond_fma_rev<mode>

- fold_left: for scalar = FN (scalar, vector), keyed off the vector mode
- check_ptrs: used for check_{raw,war}_ptrs

- cond_len_unary: a conditional unary optab, such as cond_len_neg<mode>
- cond_len_binary: a conditional binary optab, such as cond_len_add<mode>
- cond_len_ternary: a conditional ternary optab, such as
cond_len_fma_rev<mode>

DEF_INTERNAL_SIGNED_OPTAB_FN defines an internal function that
maps to one of two optabs, depending on the signedness of an input.
SIGNED_OPTAB and UNSIGNED_OPTAB are the optabs for signed and
unsigned inputs respectively, both without the trailing "_optab".
SELECTOR says which type in the tree_pair determines the signedness.

DEF_INTERNAL_FLT_FN is like DEF_INTERNAL_OPTAB_FN, but in addition,
the function implements the computational part of a built-in math
function BUILT_IN_<NAME>{F,,L}.  Unlike some built-in functions,
these internal functions never set errno.

DEF_INTERNAL_INT_FN is like DEF_INTERNAL_OPTAB_FN, but in addition
says that the function extends the C-level BUILT_IN_<NAME>{,L,LL,IMAX}
group of functions to any integral mode (including vector modes).

DEF_INTERNAL_INT_EXT_FN is like DEF_INTERNAL_INT_FN, except that it
has expand_##NAME defined in internal-fn.cc to override the
DEF_INTERNAL_INT_FN expansion behavior.

DEF_INTERNAL_WIDENING_OPTAB_FN is a wrapper that defines five internal
functions with DEF_INTERNAL_SIGNED_OPTAB_FN:
- one that describes a widening operation with the same number of elements
in the output and input vectors,
- two that describe a pair of high-low widening operations where the output
vectors each have half the number of elements of the input vectors,
corresponding to the result of the widening operation on the top half and
bottom half, these have the suffixes _HI and _LO,
- and two that describe a pair of even-odd widening operations where the
output vectors each have half the number of elements of the input vectors,
corresponding to the result of the widening operation on the even and odd
elements, these have the suffixes _EVEN and _ODD.
These five internal functions will require two optabs each, a SIGNED_OPTAB
and an UNSIGNED_OTPAB.

DEF_INTERNAL_COND_FN is a wrapper that defines 2 internal functions with
DEF_INTERNAL_OPTAB_FN:
- One is COND_* operations that are predicated by mask only. Such operations
  make sense for both vectors and scalars.
- The other is COND_LEN_* operations that are predicated by mask and len
  both. Such operations only make sense for vectors.

DEF_INTERNAL_SIGNED_COND_FN is like DEF_INTERNAL_COND_FN but defines intenal
functions with DEF_INTERNAL_SIGNED_OPTAB_FN.

Each entry must have a corresponding expander of the form:

  void expand_NAME (gimple_call stmt)

where STMT is the statement that performs the call.  These are generated
automatically for optab functions and call out to a function or macro
called expand_<TYPE>_optab_fn.   
Extract the last active element from a vector.   
Same, but return the first argument if no elements are active.   
Unary math functions.   
Floating-point to integer conversions.

??? Here we preserve the I/L/LL prefix convention from the
corresponding built-in functions, rather than make the internal
functions polymorphic in both the argument and the return types.
Perhaps an alternative would be to pass a zero of the required
return type as a second parameter.   
FP rounding.   
Binary math functions.   
FP scales.   
Ternary math functions.   
Unary integer ops.   
An unduplicable, uncombinable function.  Generally used to preserve
a CFG property in the face of jump threading, tail merging or
other such optimizations.  The first argument distinguishes
between uses.  See internal-fn.h for usage.   
A function to represent an artifical initialization to an uninitialized
automatic variable.   
A function to associate the access size and access mode information
with the corresponding reference to an object.  It only reads from the
2nd argument.   
DIM_SIZE and DIM_POS return the size of a particular compute
dimension and the executing thread's position within that
dimension.  DIM_POS is pure (and not const) so that it isn't
thought to clobber memory and can be gcse'd within a single
parallel region, but not across FORK/JOIN boundaries.  They take a
single INTEGER_CST argument.  This might be overly conservative.   
OpenACC looping abstraction.  See internal-fn.h for usage.   
OpenACC reduction abstraction.  See internal-fn.h  for usage.   
Openacc tile abstraction. Describes the spans of the element loop.
GOACC_TILE (num-loops, loop-no, tile-arg, tile-mask, element-mask).   
Set errno to EDOM, if GCC knows how to do that directly for the
current target.   
Atomic functions.  These don't have ECF_NOTHROW because for
-fnon-call-exceptions they can throw, otherwise we set
gimple_call_nothrow_p on it.   
To implement [[fallthrough]].  If the TREE_NOTHROW or GF_CALL_NOTHROW flag
is set on the call (normally redundant with ECF_NOTHROW), it marks
[[fallthrough]] at the end of C++ loop body.   
To implement __builtin_launder.   
Divmod function.   
For coroutines.   
A NOP function with arbitrary arguments and return value.   
Temporary vehicle for __builtin_shufflevector.   
<=> optimization.   
[[assume (cond)]].   
For if-conversion of inbranch SIMD clones.   
_BitInt support.   
Bitwise functions.

References gcc_unreachable.

◆ direct_internal_fn_optab() [2/2]

optab direct_internal_fn_optab ( internal_fn fn,
tree_pair types ) 
Return the optab used by internal function FN.   
Internal functions.
   Copyright (C) 2011-2024 Free Software Foundation, Inc.

This file is part of GCC.

GCC is free software; you can redistribute it and/or modify it under
the terms of the GNU General Public License as published by the Free
Software Foundation; either version 3, or (at your option) any later
version.

GCC is distributed in the hope that it will be useful, but WITHOUT ANY
WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
for more details.

You should have received a copy of the GNU General Public License
along with GCC; see the file COPYING3.  If not see
<http://www.gnu.org/licenses/>.   
This file specifies a list of internal "functions".  These functions
differ from built-in functions in that they have no linkage and cannot
be called directly by the user.  They represent operations that are only
synthesised by GCC itself.

Internal functions are used instead of tree codes if the operation
and its operands are more naturally represented as a GIMPLE_CALL
than a GIMPLE_ASSIGN.

Each entry in this file has one of the forms:

  DEF_INTERNAL_FN (NAME, FLAGS, FNSPEC)
  DEF_INTERNAL_OPTAB_FN (NAME, FLAGS, OPTAB, TYPE)
  DEF_INTERNAL_SIGNED_OPTAB_FN (NAME, FLAGS, SELECTOR, SIGNED_OPTAB,
                           UNSIGNED_OPTAB, TYPE)
  DEF_INTERNAL_FLT_FN (NAME, FLAGS, OPTAB, TYPE)
  DEF_INTERNAL_FLT_FLOATN_FN (NAME, FLAGS, OPTAB, TYPE)
  DEF_INTERNAL_INT_FN (NAME, FLAGS, OPTAB, TYPE)
  DEF_INTERNAL_INT_EXT_FN (NAME, FLAGS, OPTAB, TYPE)
  DEF_INTERNAL_COND_FN (NAME, FLAGS, OPTAB, TYPE)
  DEF_INTERNAL_SIGNED_COND_FN (NAME, FLAGS, OPTAB, TYPE)
  DEF_INTERNAL_WIDENING_OPTAB_FN (NAME, FLAGS, SELECTOR, SOPTAB, UOPTAB,
                             TYPE)

where NAME is the name of the function, FLAGS is a set of
ECF_* flags and FNSPEC is a string describing functions fnspec.

DEF_INTERNAL_OPTAB_FN defines an internal function that maps to a
direct optab.  The function should only be called with a given
set of types if the associated optab is available for the modes
of those types.  OPTAB says what optab to use (without the trailing
"_optab") and TYPE categorizes the optab based on its inputs and
outputs.  The possible types of optab are:

- mask_load: currently just maskload
- load_lanes: currently just vec_load_lanes
- mask_load_lanes: currently just vec_mask_load_lanes
- mask_len_load_lanes: currently just vec_mask_len_load_lanes
- gather_load: used for {mask_,mask_len_,}gather_load
- len_load: currently just len_load
- mask_len_load: currently just mask_len_load

- mask_store: currently just maskstore
- store_lanes: currently just vec_store_lanes
- mask_store_lanes: currently just vec_mask_store_lanes
- mask_len_store_lanes: currently just vec_mask_len_store_lanes
- scatter_store: used for {mask_,mask_len_,}scatter_store
- len_store: currently just len_store
- mask_len_store: currently just mask_len_store

- unary: a normal unary optab, such as vec_reverse_<mode>
- binary: a normal binary optab, such as vec_interleave_lo_<mode>
- ternary: a normal ternary optab, such as fma<mode>4

- unary_convert: a single-input conversion optab, such as
  lround<srcmode><dstmode>2.

- cond_binary: a conditional binary optab, such as cond_add<mode>
- cond_unary: a conditional unary optab, such as cond_neg<mode>
- cond_ternary: a conditional ternary optab, such as cond_fma_rev<mode>

- fold_left: for scalar = FN (scalar, vector), keyed off the vector mode
- check_ptrs: used for check_{raw,war}_ptrs

- cond_len_unary: a conditional unary optab, such as cond_len_neg<mode>
- cond_len_binary: a conditional binary optab, such as cond_len_add<mode>
- cond_len_ternary: a conditional ternary optab, such as
cond_len_fma_rev<mode>

DEF_INTERNAL_SIGNED_OPTAB_FN defines an internal function that
maps to one of two optabs, depending on the signedness of an input.
SIGNED_OPTAB and UNSIGNED_OPTAB are the optabs for signed and
unsigned inputs respectively, both without the trailing "_optab".
SELECTOR says which type in the tree_pair determines the signedness.

DEF_INTERNAL_FLT_FN is like DEF_INTERNAL_OPTAB_FN, but in addition,
the function implements the computational part of a built-in math
function BUILT_IN_<NAME>{F,,L}.  Unlike some built-in functions,
these internal functions never set errno.

DEF_INTERNAL_INT_FN is like DEF_INTERNAL_OPTAB_FN, but in addition
says that the function extends the C-level BUILT_IN_<NAME>{,L,LL,IMAX}
group of functions to any integral mode (including vector modes).

DEF_INTERNAL_INT_EXT_FN is like DEF_INTERNAL_INT_FN, except that it
has expand_##NAME defined in internal-fn.cc to override the
DEF_INTERNAL_INT_FN expansion behavior.

DEF_INTERNAL_WIDENING_OPTAB_FN is a wrapper that defines five internal
functions with DEF_INTERNAL_SIGNED_OPTAB_FN:
- one that describes a widening operation with the same number of elements
in the output and input vectors,
- two that describe a pair of high-low widening operations where the output
vectors each have half the number of elements of the input vectors,
corresponding to the result of the widening operation on the top half and
bottom half, these have the suffixes _HI and _LO,
- and two that describe a pair of even-odd widening operations where the
output vectors each have half the number of elements of the input vectors,
corresponding to the result of the widening operation on the even and odd
elements, these have the suffixes _EVEN and _ODD.
These five internal functions will require two optabs each, a SIGNED_OPTAB
and an UNSIGNED_OTPAB.

DEF_INTERNAL_COND_FN is a wrapper that defines 2 internal functions with
DEF_INTERNAL_OPTAB_FN:
- One is COND_* operations that are predicated by mask only. Such operations
  make sense for both vectors and scalars.
- The other is COND_LEN_* operations that are predicated by mask and len
  both. Such operations only make sense for vectors.

DEF_INTERNAL_SIGNED_COND_FN is like DEF_INTERNAL_COND_FN but defines intenal
functions with DEF_INTERNAL_SIGNED_OPTAB_FN.

Each entry must have a corresponding expander of the form:

  void expand_NAME (gimple_call stmt)

where STMT is the statement that performs the call.  These are generated
automatically for optab functions and call out to a function or macro
called expand_<TYPE>_optab_fn.   
Extract the last active element from a vector.   
Same, but return the first argument if no elements are active.   
Unary math functions.   
Floating-point to integer conversions.

??? Here we preserve the I/L/LL prefix convention from the
corresponding built-in functions, rather than make the internal
functions polymorphic in both the argument and the return types.
Perhaps an alternative would be to pass a zero of the required
return type as a second parameter.   
FP rounding.   
Binary math functions.   
FP scales.   
Ternary math functions.   
Unary integer ops.   
An unduplicable, uncombinable function.  Generally used to preserve
a CFG property in the face of jump threading, tail merging or
other such optimizations.  The first argument distinguishes
between uses.  See internal-fn.h for usage.   
A function to represent an artifical initialization to an uninitialized
automatic variable.   
A function to associate the access size and access mode information
with the corresponding reference to an object.  It only reads from the
2nd argument.   
DIM_SIZE and DIM_POS return the size of a particular compute
dimension and the executing thread's position within that
dimension.  DIM_POS is pure (and not const) so that it isn't
thought to clobber memory and can be gcse'd within a single
parallel region, but not across FORK/JOIN boundaries.  They take a
single INTEGER_CST argument.  This might be overly conservative.   
OpenACC looping abstraction.  See internal-fn.h for usage.   
OpenACC reduction abstraction.  See internal-fn.h  for usage.   
Openacc tile abstraction. Describes the spans of the element loop.
GOACC_TILE (num-loops, loop-no, tile-arg, tile-mask, element-mask).   
Set errno to EDOM, if GCC knows how to do that directly for the
current target.   
Atomic functions.  These don't have ECF_NOTHROW because for
-fnon-call-exceptions they can throw, otherwise we set
gimple_call_nothrow_p on it.   
To implement [[fallthrough]].  If the TREE_NOTHROW or GF_CALL_NOTHROW flag
is set on the call (normally redundant with ECF_NOTHROW), it marks
[[fallthrough]] at the end of C++ loop body.   
To implement __builtin_launder.   
Divmod function.   
For coroutines.   
A NOP function with arbitrary arguments and return value.   
Temporary vehicle for __builtin_shufflevector.   
<=> optimization.   
[[assume (cond)]].   
For if-conversion of inbranch SIMD clones.   
_BitInt support.   
Bitwise functions.

References gcc_unreachable.

Referenced by internal_check_ptrs_fn_supported_p(), internal_gather_scatter_fn_supported_p(), internal_len_load_store_bias(), and supportable_widening_operation().

◆ direct_internal_fn_supported_p() [1/3]

bool direct_internal_fn_supported_p ( gcall * stmt,
optimization_type opt_type ) 
Return true if the STMT is supported when the optimization type is OPT_TYPE,
given that STMT is a call to a direct internal function.

References direct_internal_fn_supported_p(), direct_internal_fn_types(), and gimple_call_internal_fn().

◆ direct_internal_fn_supported_p() [2/3]

bool direct_internal_fn_supported_p ( internal_fn fn,
tree type,
optimization_type opt_type ) 
Return true if FN is supported for type TYPE when the optimization
type is OPT_TYPE.  The caller knows that the "type0" and "type1"
fields of FN's direct_internal_fn_info structure are the same.

References direct_internal_fn(), direct_internal_fn_supported_p(), gcc_checking_assert, direct_internal_fn_info::type0, and direct_internal_fn_info::type1.

◆ direct_internal_fn_supported_p() [3/3]

bool direct_internal_fn_supported_p ( internal_fn fn,
tree_pair types,
optimization_type opt_type ) 
Return true if FN is supported for the types in TYPES when the
optimization type is OPT_TYPE.  The types are those associated with
the "type0" and "type1" fields of FN's direct_internal_fn_info
structure.   
Internal functions.
   Copyright (C) 2011-2024 Free Software Foundation, Inc.

This file is part of GCC.

GCC is free software; you can redistribute it and/or modify it under
the terms of the GNU General Public License as published by the Free
Software Foundation; either version 3, or (at your option) any later
version.

GCC is distributed in the hope that it will be useful, but WITHOUT ANY
WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
for more details.

You should have received a copy of the GNU General Public License
along with GCC; see the file COPYING3.  If not see
<http://www.gnu.org/licenses/>.   
This file specifies a list of internal "functions".  These functions
differ from built-in functions in that they have no linkage and cannot
be called directly by the user.  They represent operations that are only
synthesised by GCC itself.

Internal functions are used instead of tree codes if the operation
and its operands are more naturally represented as a GIMPLE_CALL
than a GIMPLE_ASSIGN.

Each entry in this file has one of the forms:

  DEF_INTERNAL_FN (NAME, FLAGS, FNSPEC)
  DEF_INTERNAL_OPTAB_FN (NAME, FLAGS, OPTAB, TYPE)
  DEF_INTERNAL_SIGNED_OPTAB_FN (NAME, FLAGS, SELECTOR, SIGNED_OPTAB,
                           UNSIGNED_OPTAB, TYPE)
  DEF_INTERNAL_FLT_FN (NAME, FLAGS, OPTAB, TYPE)
  DEF_INTERNAL_FLT_FLOATN_FN (NAME, FLAGS, OPTAB, TYPE)
  DEF_INTERNAL_INT_FN (NAME, FLAGS, OPTAB, TYPE)
  DEF_INTERNAL_INT_EXT_FN (NAME, FLAGS, OPTAB, TYPE)
  DEF_INTERNAL_COND_FN (NAME, FLAGS, OPTAB, TYPE)
  DEF_INTERNAL_SIGNED_COND_FN (NAME, FLAGS, OPTAB, TYPE)
  DEF_INTERNAL_WIDENING_OPTAB_FN (NAME, FLAGS, SELECTOR, SOPTAB, UOPTAB,
                             TYPE)

where NAME is the name of the function, FLAGS is a set of
ECF_* flags and FNSPEC is a string describing functions fnspec.

DEF_INTERNAL_OPTAB_FN defines an internal function that maps to a
direct optab.  The function should only be called with a given
set of types if the associated optab is available for the modes
of those types.  OPTAB says what optab to use (without the trailing
"_optab") and TYPE categorizes the optab based on its inputs and
outputs.  The possible types of optab are:

- mask_load: currently just maskload
- load_lanes: currently just vec_load_lanes
- mask_load_lanes: currently just vec_mask_load_lanes
- mask_len_load_lanes: currently just vec_mask_len_load_lanes
- gather_load: used for {mask_,mask_len_,}gather_load
- len_load: currently just len_load
- mask_len_load: currently just mask_len_load

- mask_store: currently just maskstore
- store_lanes: currently just vec_store_lanes
- mask_store_lanes: currently just vec_mask_store_lanes
- mask_len_store_lanes: currently just vec_mask_len_store_lanes
- scatter_store: used for {mask_,mask_len_,}scatter_store
- len_store: currently just len_store
- mask_len_store: currently just mask_len_store

- unary: a normal unary optab, such as vec_reverse_<mode>
- binary: a normal binary optab, such as vec_interleave_lo_<mode>
- ternary: a normal ternary optab, such as fma<mode>4

- unary_convert: a single-input conversion optab, such as
  lround<srcmode><dstmode>2.

- cond_binary: a conditional binary optab, such as cond_add<mode>
- cond_unary: a conditional unary optab, such as cond_neg<mode>
- cond_ternary: a conditional ternary optab, such as cond_fma_rev<mode>

- fold_left: for scalar = FN (scalar, vector), keyed off the vector mode
- check_ptrs: used for check_{raw,war}_ptrs

- cond_len_unary: a conditional unary optab, such as cond_len_neg<mode>
- cond_len_binary: a conditional binary optab, such as cond_len_add<mode>
- cond_len_ternary: a conditional ternary optab, such as
cond_len_fma_rev<mode>

DEF_INTERNAL_SIGNED_OPTAB_FN defines an internal function that
maps to one of two optabs, depending on the signedness of an input.
SIGNED_OPTAB and UNSIGNED_OPTAB are the optabs for signed and
unsigned inputs respectively, both without the trailing "_optab".
SELECTOR says which type in the tree_pair determines the signedness.

DEF_INTERNAL_FLT_FN is like DEF_INTERNAL_OPTAB_FN, but in addition,
the function implements the computational part of a built-in math
function BUILT_IN_<NAME>{F,,L}.  Unlike some built-in functions,
these internal functions never set errno.

DEF_INTERNAL_INT_FN is like DEF_INTERNAL_OPTAB_FN, but in addition
says that the function extends the C-level BUILT_IN_<NAME>{,L,LL,IMAX}
group of functions to any integral mode (including vector modes).

DEF_INTERNAL_INT_EXT_FN is like DEF_INTERNAL_INT_FN, except that it
has expand_##NAME defined in internal-fn.cc to override the
DEF_INTERNAL_INT_FN expansion behavior.

DEF_INTERNAL_WIDENING_OPTAB_FN is a wrapper that defines five internal
functions with DEF_INTERNAL_SIGNED_OPTAB_FN:
- one that describes a widening operation with the same number of elements
in the output and input vectors,
- two that describe a pair of high-low widening operations where the output
vectors each have half the number of elements of the input vectors,
corresponding to the result of the widening operation on the top half and
bottom half, these have the suffixes _HI and _LO,
- and two that describe a pair of even-odd widening operations where the
output vectors each have half the number of elements of the input vectors,
corresponding to the result of the widening operation on the even and odd
elements, these have the suffixes _EVEN and _ODD.
These five internal functions will require two optabs each, a SIGNED_OPTAB
and an UNSIGNED_OTPAB.

DEF_INTERNAL_COND_FN is a wrapper that defines 2 internal functions with
DEF_INTERNAL_OPTAB_FN:
- One is COND_* operations that are predicated by mask only. Such operations
  make sense for both vectors and scalars.
- The other is COND_LEN_* operations that are predicated by mask and len
  both. Such operations only make sense for vectors.

DEF_INTERNAL_SIGNED_COND_FN is like DEF_INTERNAL_COND_FN but defines intenal
functions with DEF_INTERNAL_SIGNED_OPTAB_FN.

Each entry must have a corresponding expander of the form:

  void expand_NAME (gimple_call stmt)

where STMT is the statement that performs the call.  These are generated
automatically for optab functions and call out to a function or macro
called expand_<TYPE>_optab_fn.   
Extract the last active element from a vector.   
Same, but return the first argument if no elements are active.   
Unary math functions.   
Floating-point to integer conversions.

??? Here we preserve the I/L/LL prefix convention from the
corresponding built-in functions, rather than make the internal
functions polymorphic in both the argument and the return types.
Perhaps an alternative would be to pass a zero of the required
return type as a second parameter.   
FP rounding.   
Binary math functions.   
FP scales.   
Ternary math functions.   
Unary integer ops.   
An unduplicable, uncombinable function.  Generally used to preserve
a CFG property in the face of jump threading, tail merging or
other such optimizations.  The first argument distinguishes
between uses.  See internal-fn.h for usage.   
A function to represent an artifical initialization to an uninitialized
automatic variable.   
A function to associate the access size and access mode information
with the corresponding reference to an object.  It only reads from the
2nd argument.   
DIM_SIZE and DIM_POS return the size of a particular compute
dimension and the executing thread's position within that
dimension.  DIM_POS is pure (and not const) so that it isn't
thought to clobber memory and can be gcse'd within a single
parallel region, but not across FORK/JOIN boundaries.  They take a
single INTEGER_CST argument.  This might be overly conservative.   
OpenACC looping abstraction.  See internal-fn.h for usage.   
OpenACC reduction abstraction.  See internal-fn.h  for usage.   
Openacc tile abstraction. Describes the spans of the element loop.
GOACC_TILE (num-loops, loop-no, tile-arg, tile-mask, element-mask).   
Set errno to EDOM, if GCC knows how to do that directly for the
current target.   
Atomic functions.  These don't have ECF_NOTHROW because for
-fnon-call-exceptions they can throw, otherwise we set
gimple_call_nothrow_p on it.   
To implement [[fallthrough]].  If the TREE_NOTHROW or GF_CALL_NOTHROW flag
is set on the call (normally redundant with ECF_NOTHROW), it marks
[[fallthrough]] at the end of C++ loop body.   
To implement __builtin_launder.   
Divmod function.   
For coroutines.   
A NOP function with arbitrary arguments and return value.   
Temporary vehicle for __builtin_shufflevector.   
<=> optimization.   
[[assume (cond)]].   
For if-conversion of inbranch SIMD clones.   
_BitInt support.   
Bitwise functions.

References gcc_unreachable, and type_pair_strictly_matches_mode_p().

Referenced by build_call_internal(), build_cltz_expr(), build_popcount_expr(), build_saturation_binary_arith_call(), build_saturation_binary_arith_call(), can_log2(), can_produce_all_loop_masks_p(), cond_removal_in_builtin_zero_pattern(), convert_mult_to_fma(), direct_internal_fn_supported_p(), direct_internal_fn_supported_p(), direct_internal_fn_supported_p(), directly_supported_p(), directly_supported_p(), fold_builtin_bit_query(), get_masked_reduction_fn(), gimple_expand_vec_cond_expr(), internal_fn_reciprocal(), match_single_bit_test(), match_unsigned_saturation_trunc(), maybe_build_call_expr_loc(), optimize_count_trailing_zeroes(), reassociate_bb(), replacement_internal_fn(), try_vectorize_loop_1(), use_mask_by_cond_expr_p(), vect_analyze_loop_2(), vect_gen_while(), vect_pattern_validate_optab(), vect_recog_abd_pattern(), vect_recog_average_pattern(), vect_recog_build_binary_gimple_stmt(), vect_recog_ctz_ffs_pattern(), vect_recog_divmod_pattern(), vect_recog_mulhs_pattern(), vect_recog_popcount_clz_ctz_ffs_pattern(), vect_recog_pow_pattern(), vect_recog_sat_sub_pattern_transform(), vect_recog_sat_trunc_pattern(), vect_reduction_update_partial_vector_usage(), vectorizable_bb_reduc_epilogue(), vectorizable_call(), vectorizable_condition(), vectorizable_early_exit(), vectorizable_internal_function(), vectorizable_live_operation(), vectorizable_operation(), vectorizable_reduction(), and vectorized_internal_fn_supported_p().

◆ direct_internal_fn_types() [1/2]

tree_pair direct_internal_fn_types ( internal_fn fn,
gcall * call ) 
CALL is a call whose return type and arguments are in principle
compatible with FN (which satisfies direct_internal_fn_p).  Return the
types that should be used to determine whether the target supports FN.

References direct_internal_fn(), gimple_call_arg(), gimple_call_lhs(), separate_ops::op0, separate_ops::op1, TREE_TYPE, direct_internal_fn_info::type0, and direct_internal_fn_info::type1.

◆ direct_internal_fn_types() [2/2]

tree_pair direct_internal_fn_types ( internal_fn fn,
tree return_type,
tree * args ) 
RETURN_TYPE and ARGS are a return type and argument list that are
in principle compatible with FN (which satisfies direct_internal_fn_p).
Return the types that should be used to determine whether the
target supports FN.

References direct_internal_fn(), TREE_TYPE, direct_internal_fn_info::type0, and direct_internal_fn_info::type1.

Referenced by build_call_internal(), direct_internal_fn_supported_p(), expand_convert_optab_fn(), expand_direct_optab_fn(), internal_fn_reciprocal(), maybe_build_call_expr_loc(), and replacement_internal_fn().

◆ direct_optab_supported_p()

static bool direct_optab_supported_p ( direct_optab optab,
tree_pair types,
optimization_type opt_type )
static 
Return true if OPTAB is supported for TYPES (whose modes should be
the same) when the optimization type is OPT_TYPE.  Used for simple
direct optabs.

References direct_optab_handler(), gcc_checking_assert, and TYPE_MODE.

◆ expand_ABNORMAL_DISPATCHER()

static void expand_ABNORMAL_DISPATCHER ( internal_fn ,
gcall *  )
static

◆ expand_ACCESS_WITH_SIZE()

static void expand_ACCESS_WITH_SIZE ( internal_fn ,
gcall * stmt )
static 
Expand the IFN_ACCESS_WITH_SIZE function:
ACCESS_WITH_SIZE (REF_TO_OBJ, REF_TO_SIZE, CLASS_OF_SIZE,
             TYPE_OF_SIZE, ACCESS_MODE)
which returns the REF_TO_OBJ same as the 1st argument;

1st argument REF_TO_OBJ: The reference to the object;
2nd argument REF_TO_SIZE: The reference to the size of the object,
3rd argument CLASS_OF_SIZE: The size referenced by the REF_TO_SIZE represents
  0: the number of bytes.
  1: the number of the elements of the object type;
4th argument TYPE_OF_SIZE: A constant 0 with its TYPE being the same as the TYPE
 of the object referenced by REF_TO_SIZE
5th argument ACCESS_MODE:
 -1: Unknown access semantics
  0: none
  1: read_only
  2: write_only
  3: read_write
6th argument: A constant 0 with the pointer TYPE to the original flexible
  array type.

Both the return type and the type of the first argument of this
function have been converted from the incomplete array type to
the corresponding pointer type.

For each call to a .ACCESS_WITH_SIZE, replace it with its 1st argument.

References expand_assignment(), gimple_call_arg(), and gimple_call_lhs().

◆ expand_ADD_OVERFLOW()

static void expand_ADD_OVERFLOW ( internal_fn ,
gcall * stmt )
static 
Expand ADD_OVERFLOW STMT.

References expand_arith_overflow().

◆ expand_addsub_overflow()

void expand_addsub_overflow ( location_t loc,
tree_code code,
tree lhs,
tree arg0,
tree arg1,
bool unsr_p,
bool uns0_p,
bool uns1_p,
bool is_ubsan,
tree * datap ) 
Add sub/add overflow checking to the statement STMT.
CODE says whether the operation is +, or -.

References add_reg_br_prob_note(), any_condjump_p(), BITS_PER_WORD, cfun, const0_rtx, CONST_SCALAR_INT_P, create_fixed_operand(), create_input_operand(), create_output_operand(), delete_insns_since(), do_compare_rtx_and_jump(), do_pending_stack_adjust(), emit_jump(), emit_label(), error_mark_node, profile_probability::even(), expand_arith_overflow_result_store(), expand_arith_set_overflow(), expand_binop(), expand_expr(), expand_normal(), expand_ubsan_result_store(), expand_unop(), EXPAND_WRITE, find_reg_note(), gcc_assert, gen_label_rtx(), gen_reg_rtx(), get_last_insn(), GET_MODE_PRECISION(), get_range_pos_neg(), immed_wide_int_const(), JUMP_P, last, maybe_expand_insn(), wi::min_value(), expand_operand::mode, NULL, NULL_RTX, optab_handler(), OPTAB_LIB_WIDEN, pop_temp_slots(), PROFILE_ABSENT, profile_status_for_fn, push_temp_slots(), REG_P, SCALAR_INT_TYPE_MODE, SIGNED, expand_operand::target, TREE_TYPE, ubsan_build_overflow_builtin(), profile_probability::very_likely(), profile_probability::very_unlikely(), and write_complex_part().

Referenced by expand_arith_overflow(), expand_doubleword_mod(), expand_UBSAN_CHECK_ADD(), expand_UBSAN_CHECK_SUB(), and expand_vector_ubsan_overflow().

◆ expand_ANNOTATE()

static void expand_ANNOTATE ( internal_fn ,
gcall *  )
static

References gcc_unreachable.

◆ expand_arith_overflow()

static void expand_arith_overflow ( enum tree_code code,
gimple * stmt )
static 
Helper function for {ADD,SUB,MUL}_OVERFLOW call stmt expansion.

References BITS_PER_WORD, build_nonstandard_integer_type(), separate_ops::code, const0_rtx, expand_addsub_overflow(), expand_arith_overflow_result_store(), expand_expr(), expand_expr_real_2(), expand_mul_overflow(), expand_neg_overflow(), EXPAND_NORMAL, EXPAND_WRITE, fold_convert_loc(), gcc_unreachable, get_min_precision(), GET_MODE_PRECISION(), get_range_pos_neg(), gimple_call_arg(), gimple_call_lhs(), gimple_location(), integer_zerop(), separate_ops::location, MAX, MIN, NULL, NULL_RTX, NULL_TREE, separate_ops::op0, separate_ops::op1, separate_ops::op2, opt_mode< T >::require(), SCALAR_INT_TYPE_MODE, SIGNED, smallest_int_mode_for_size(), targetm, TREE_TYPE, separate_ops::type, type(), TYPE_PRECISION, TYPE_UNSIGNED, UNSIGNED, and write_complex_part().

Referenced by expand_ADD_OVERFLOW(), expand_MUL_OVERFLOW(), and expand_SUB_OVERFLOW().

◆ expand_arith_overflow_result_store()

static void expand_arith_overflow_result_store ( tree lhs,
rtx target,
scalar_int_mode mode,
rtx res )
static 
Helper for expand_*_overflow.  Store RES into the __real__ part
of TARGET.  If RES has larger MODE than __real__ part of TARGET,
set the __imag__ part to 1 if RES doesn't fit into it.  Similarly
if LHS has smaller precision than its mode.

References as_a(), convert_modes(), do_compare_rtx_and_jump(), emit_label(), expand_arith_set_overflow(), expand_shift(), expand_simple_binop(), gcc_assert, gen_label_rtx(), GET_MODE, GET_MODE_INNER, GET_MODE_PRECISION(), immed_wide_int_const(), expand_operand::mode, NULL, NULL_RTX, OPTAB_LIB_WIDEN, wi::shifted_mask(), expand_operand::target, TREE_TYPE, TYPE_PRECISION, TYPE_UNSIGNED, profile_probability::very_likely(), and write_complex_part().

Referenced by expand_addsub_overflow(), expand_arith_overflow(), expand_mul_overflow(), and expand_neg_overflow().

◆ expand_arith_set_overflow()

static void expand_arith_set_overflow ( tree lhs,
rtx target )
static 
Helper for expand_*_overflow.  Set the __imag__ part to true
(1 except for signed:1 type, in which case store -1).

References const1_rtx, constm1_rtx, expand_operand::target, TREE_TYPE, TYPE_PRECISION, TYPE_UNSIGNED, and write_complex_part().

Referenced by expand_addsub_overflow(), expand_arith_overflow_result_store(), expand_mul_overflow(), and expand_neg_overflow().

◆ expand_ASAN_CHECK()

static void expand_ASAN_CHECK ( internal_fn ,
gcall *  )
static 
This should get expanded in the sanopt pass.

References gcc_unreachable.

◆ expand_ASAN_MARK()

static void expand_ASAN_MARK ( internal_fn ,
gcall *  )
static 
This should get expanded in the sanopt pass.

References gcc_unreachable.

◆ expand_ASAN_POISON()

static void expand_ASAN_POISON ( internal_fn ,
gcall *  )
static 
This should get expanded in the sanopt pass.

References gcc_unreachable.

◆ expand_ASAN_POISON_USE()

static void expand_ASAN_POISON_USE ( internal_fn ,
gcall *  )
static 
This should get expanded in the sanopt pass.

References gcc_unreachable.

◆ expand_ASSUME()

void expand_ASSUME ( internal_fn ,
gcall *  )

◆ expand_ATOMIC_ADD_FETCH_CMP_0()

static void expand_ATOMIC_ADD_FETCH_CMP_0 ( internal_fn ,
gcall * call )
static 
Expand atomic add fetch and cmp with 0.

References expand_ifn_atomic_op_fetch_cmp_0().

◆ expand_ATOMIC_AND_FETCH_CMP_0()

static void expand_ATOMIC_AND_FETCH_CMP_0 ( internal_fn ,
gcall * call )
static 
Expand atomic and fetch and cmp with 0.

References expand_ifn_atomic_op_fetch_cmp_0().

◆ expand_ATOMIC_BIT_TEST_AND_COMPLEMENT()

static void expand_ATOMIC_BIT_TEST_AND_COMPLEMENT ( internal_fn ,
gcall * call )
static 
Expand atomic bit test and complement.

References expand_ifn_atomic_bit_test_and().

◆ expand_ATOMIC_BIT_TEST_AND_RESET()

static void expand_ATOMIC_BIT_TEST_AND_RESET ( internal_fn ,
gcall * call )
static 
Expand atomic bit test and reset.

References expand_ifn_atomic_bit_test_and().

◆ expand_ATOMIC_BIT_TEST_AND_SET()

static void expand_ATOMIC_BIT_TEST_AND_SET ( internal_fn ,
gcall * call )
static 
Expand atomic bit test and set.

References expand_ifn_atomic_bit_test_and().

◆ expand_ATOMIC_COMPARE_EXCHANGE()

static void expand_ATOMIC_COMPARE_EXCHANGE ( internal_fn ,
gcall * call )
static 
Expand atomic bit test and set.

References expand_ifn_atomic_compare_exchange().

◆ expand_ATOMIC_OR_FETCH_CMP_0()

static void expand_ATOMIC_OR_FETCH_CMP_0 ( internal_fn ,
gcall * call )
static 
Expand atomic or fetch and cmp with 0.

References expand_ifn_atomic_op_fetch_cmp_0().

◆ expand_ATOMIC_SUB_FETCH_CMP_0()

static void expand_ATOMIC_SUB_FETCH_CMP_0 ( internal_fn ,
gcall * call )
static 
Expand atomic sub fetch and cmp with 0.

References expand_ifn_atomic_op_fetch_cmp_0().

◆ expand_ATOMIC_XOR_FETCH_CMP_0()

static void expand_ATOMIC_XOR_FETCH_CMP_0 ( internal_fn ,
gcall * call )
static 
Expand atomic xor fetch and cmp with 0.

References expand_ifn_atomic_op_fetch_cmp_0().

◆ expand_BITINTTOFLOAT()

void expand_BITINTTOFLOAT ( internal_fn ,
gcall * stmt )

References DECIMAL_FLOAT_MODE_P, emit_library_call_value(), emit_move_insn(), expand_expr(), expand_normal(), EXPAND_WRITE, GET_MODE_NAME, gimple_call_arg(), gimple_call_lhs(), init_one_libfunc(), LCT_PURE, expand_operand::mode, NULL_RTX, ptr_mode, expand_operand::target, TREE_TYPE, and TYPE_MODE.

◆ expand_bitquery()

static bool expand_bitquery ( internal_fn fn,
gcall * stmt )
static

References as_combined_fn(), expand_assignment(), fold_const_call(), gcc_checking_assert, gimple_call_arg(), gimple_call_lhs(), NULL_TREE, TREE_CODE, and TREE_TYPE.

Referenced by expand_CLRSB(), expand_CLZ(), expand_CTZ(), expand_FFS(), expand_PARITY(), and expand_POPCOUNT().

◆ expand_BUILTIN_EXPECT()

static void expand_BUILTIN_EXPECT ( internal_fn ,
gcall * stmt )
static

References const0_rtx, emit_move_insn(), expand_expr(), EXPAND_NORMAL, EXPAND_WRITE, gcc_assert, gimple_call_arg(), gimple_call_lhs(), NULL_RTX, seen_error(), and expand_operand::target.

◆ expand_call_mem_ref()

static tree expand_call_mem_ref ( tree type,
gcall * stmt,
int index )
static 
Return a memory reference of type TYPE for argument INDEX of STMT.
Use argument INDEX + 1 to derive the second (TBAA) operand.

References build_aligned_type(), build_int_cst(), copy_node(), fold_build2, get_gimple_for_ssa_name(), gimple_assign_rhs1(), gimple_assign_single_p(), gimple_call_arg(), integer_zerop(), offset, TMR_OFFSET, wi::to_poly_wide(), TREE_CODE, TREE_OPERAND, tree_to_shwi(), TREE_TYPE, type(), TYPE_ALIGN, types_compatible_p(), and wide_int_to_tree().

Referenced by expand_partial_load_optab_fn(), and expand_partial_store_optab_fn().

◆ expand_CLRSB()

void expand_CLRSB ( internal_fn fn,
gcall * stmt )

References expand_bitquery(), and expand_unary_optab_fn.

◆ expand_CLZ()

void expand_CLZ ( internal_fn fn,
gcall * stmt )

References expand_bitquery(), and expand_unary_optab_fn.

◆ expand_CO_ACTOR()

static void expand_CO_ACTOR ( internal_fn ,
gcall *  )
static

References gcc_unreachable.

◆ expand_CO_FRAME()

static void expand_CO_FRAME ( internal_fn ,
gcall *  )
static 
Coroutines, all should have been processed at this stage.

References gcc_unreachable.

◆ expand_CO_SUSPN()

static void expand_CO_SUSPN ( internal_fn ,
gcall *  )
static

References gcc_unreachable.

◆ expand_CO_YIELD()

static void expand_CO_YIELD ( internal_fn ,
gcall *  )
static

References gcc_unreachable.

◆ expand_convert_optab_fn()

static void expand_convert_optab_fn ( internal_fn fn,
gcall * stmt,
convert_optab optab,
unsigned int nargs )
static 
Expand a call to a convert-like optab using the operands in STMT.
FN has a single output operand and NARGS input operands.

References convert_optab_handler(), direct_internal_fn_types(), expand_fn_using_insn(), and TYPE_MODE.

◆ expand_CTZ()

void expand_CTZ ( internal_fn fn,
gcall * stmt )

References expand_bitquery(), and expand_unary_optab_fn.

◆ expand_DEFERRED_INIT()

static void expand_DEFERRED_INIT ( internal_fn ,
gcall * stmt )
static

References AUTO_INIT_PATTERN, AUTO_INIT_UNINITIALIZED, build1(), build_call_expr(), build_fold_addr_expr, build_int_cst(), build_nonstandard_integer_type(), build_zero_cst(), builtin_decl_implicit(), DECL_P, DECL_SIZE_UNIT, expand_assignment(), expand_builtin_memset(), fold_build1, wi::from_buffer(), gcc_assert, gimple_call_arg(), gimple_call_lhs(), handled_component_p(), have_insn_for(), INIT_PATTERN_VALUE, int_mode_for_size(), integer_type_node, integer_zero_node, integer_zerop(), is_gimple_reg_type(), mark_addressable(), mem_ref_refers_to_non_mem_p(), non_mem_decl_p(), NULL_RTX, SET, TREE_CODE, tree_fits_uhwi_p(), tree_int_cst_equal(), TREE_INT_CST_LOW, TREE_OPERAND, tree_to_uhwi(), TREE_TYPE, TYPE_MODE, expand_operand::value, and wide_int_to_tree().

◆ expand_direct_optab_fn()

static void expand_direct_optab_fn ( internal_fn fn,
gcall * stmt,
direct_optab optab,
unsigned int nargs )
static 
Expand a call to FN using the operands in STMT.  FN has a single
output operand and NARGS input operands.

References direct_internal_fn_types(), direct_optab_handler(), expand_fn_using_insn(), and TYPE_MODE.

◆ expand_DIVMOD()

static void expand_DIVMOD ( internal_fn ,
gcall * call_stmt )
static 
Expand DIVMOD() using:
a) optab handler for udivmod/sdivmod if it is available.
b) If optab_handler doesn't exist, generate call to
   target-specific divmod libfunc.

References build2(), separate_ops::code, CONST_INT_P, contains_call_div_mod(), copy_rtx(), delete_insns_since(), emit_insn(), emit_move_insn(), end_sequence(), expand_doubleword_divmod(), expand_expr(), expand_expr_real_2(), EXPAND_NORMAL, expand_normal(), expand_twoval_binop(), EXPAND_WRITE, gcc_assert, gcc_unreachable, gen_reg_rtx(), get_insns(), get_last_insn(), GET_MODE_SIZE(), gimple_call_arg(), gimple_call_lhs(), gimple_location(), insns, INTVAL, is_int_mode(), last, separate_ops::location, make_tree(), expand_operand::mode, NULL, NULL_RTX, NULL_TREE, separate_ops::op0, separate_ops::op1, separate_ops::op2, optab_handler(), optab_libfunc(), optimize_insn_for_speed_p(), pow2p_hwi(), set_dst_reg_note(), start_sequence(), expand_operand::target, targetm, TREE_CODE, TREE_TYPE, separate_ops::type, type(), TYPE_MODE, TYPE_UNSIGNED, and word_mode.

◆ expand_DIVMODBITINT()

void expand_DIVMODBITINT ( internal_fn ,
gcall * stmt )

References emit_library_call_value_1(), expand_normal(), gimple_call_arg(), i, init_one_libfunc(), LCT_NORMAL, NULL_RTX, and ptr_mode.

◆ expand_FALLTHROUGH()

static void expand_FALLTHROUGH ( internal_fn ,
gcall * call )
static 
This should get expanded in the lower pass.

References error_at(), and gimple_location().

◆ expand_FFS()

void expand_FFS ( internal_fn fn,
gcall * stmt )

References expand_bitquery(), and expand_unary_optab_fn.

◆ expand_FLOATTOBITINT()

void expand_FLOATTOBITINT ( internal_fn ,
gcall * stmt )

References DECIMAL_FLOAT_MODE_P, emit_library_call(), expand_normal(), GET_MODE_NAME, gimple_call_arg(), init_one_libfunc(), LCT_NORMAL, expand_operand::mode, ptr_mode, TREE_TYPE, and TYPE_MODE.

◆ expand_fn_using_insn()

static void expand_fn_using_insn ( gcall * stmt,
insn_code icode,
unsigned int noutputs,
unsigned int ninputs )
static 
Expand STMT using instruction ICODE.  The instruction has NOUTPUTS
output operands and NINPUTS input operands, where NOUTPUTS is either
0 or 1.  The output operand (if any) comes first, followed by the
NINPUTS input operands.

References assign_call_lhs(), create_call_lhs_operand(), create_convert_operand_from(), create_input_operand(), create_undefined_input_operand(), expand_binop(), expand_expr(), expand_insn(), expand_normal(), EXPAND_WRITE, gcc_assert, GEN_INT, GET_MODE_PRECISION(), gimple_call_arg(), gimple_call_lhs(), HOST_WIDE_INT_1U, i, insn_data, INTEGRAL_TYPE_P, NULL_RTX, OPTAB_WIDEN, SCALAR_INT_MODE_P, SSA_NAME_IS_DEFAULT_DEF, SSA_NAME_VAR, poly_int< N, C >::to_constant(), TREE_CODE, TREE_TYPE, TYPE_MODE, TYPE_UNSIGNED, TYPE_VECTOR_SUBPARTS(), VAR_P, and VECTOR_BOOLEAN_TYPE_P.

Referenced by expand_convert_optab_fn(), and expand_direct_optab_fn().

◆ expand_gather_load_optab_fn()

static void expand_gather_load_optab_fn ( internal_fn ,
gcall * stmt,
direct_optab optab )
static 
Expand {MASK_,}GATHER_LOAD call CALL using optab OPTAB.

References add_mask_and_len_args(), assign_call_lhs(), convert_optab_handler(), create_address_operand(), create_call_lhs_operand(), create_input_operand(), create_integer_operand(), expand_expr(), expand_insn(), expand_normal(), EXPAND_WRITE, gimple_call_arg(), gimple_call_lhs(), i, NULL_RTX, offset, tree_to_shwi(), TREE_TYPE, TYPE_MODE, and TYPE_UNSIGNED.

◆ expand_GOACC_DIM_POS()

static void expand_GOACC_DIM_POS ( internal_fn ,
gcall * stmt )
static 
The position of an OpenACC execution engine along one compute axis.

References const0_rtx, emit_insn(), emit_move_insn(), expand_expr(), EXPAND_NORMAL, EXPAND_WRITE, gimple_call_arg(), gimple_call_lhs(), NULL_RTX, expand_operand::target, and targetm.

◆ expand_GOACC_DIM_SIZE()

static void expand_GOACC_DIM_SIZE ( internal_fn ,
gcall * stmt )
static 
The size of an OpenACC compute dimension.

References emit_insn(), emit_move_insn(), expand_expr(), EXPAND_NORMAL, EXPAND_WRITE, GEN_INT, gimple_call_arg(), gimple_call_lhs(), NULL_RTX, expand_operand::target, and targetm.

◆ expand_GOACC_LOOP()

static void expand_GOACC_LOOP ( internal_fn ,
gcall *  )
static 
This is expanded by oacc_device_lower pass.

References gcc_unreachable.

◆ expand_GOACC_REDUCTION()

static void expand_GOACC_REDUCTION ( internal_fn ,
gcall *  )
static 
This is expanded by oacc_device_lower pass.

References gcc_unreachable.

◆ expand_GOACC_TILE()

static void expand_GOACC_TILE ( internal_fn ,
gcall *  )
static 
This is expanded by oacc_device_lower pass.

References gcc_unreachable.

◆ expand_GOMP_SIMD_LANE()

static void expand_GOMP_SIMD_LANE ( internal_fn ,
gcall *  )
static 
This should get expanded in adjust_simduid_builtins.

References gcc_unreachable.

◆ expand_GOMP_SIMD_LAST_LANE()

static void expand_GOMP_SIMD_LAST_LANE ( internal_fn ,
gcall *  )
static 
This should get expanded in adjust_simduid_builtins.

References gcc_unreachable.

◆ expand_GOMP_SIMD_ORDERED_END()

static void expand_GOMP_SIMD_ORDERED_END ( internal_fn ,
gcall *  )
static 
This should get expanded in adjust_simduid_builtins.

References gcc_unreachable.

◆ expand_GOMP_SIMD_ORDERED_START()

static void expand_GOMP_SIMD_ORDERED_START ( internal_fn ,
gcall *  )
static 
This should get expanded in adjust_simduid_builtins.

References gcc_unreachable.

◆ expand_GOMP_SIMD_VF()

static void expand_GOMP_SIMD_VF ( internal_fn ,
gcall *  )
static 
This should get expanded in adjust_simduid_builtins.

References gcc_unreachable.

◆ expand_GOMP_SIMT_ENTER()

static void expand_GOMP_SIMT_ENTER ( internal_fn ,
gcall *  )
static 
This should get expanded in omp_device_lower pass.

References gcc_unreachable.

◆ expand_GOMP_SIMT_ENTER_ALLOC()

static void expand_GOMP_SIMT_ENTER_ALLOC ( internal_fn ,
gcall * stmt )
static 
Allocate per-lane storage and begin non-uniform execution region.

References assign_call_lhs(), create_call_lhs_operand(), create_input_operand(), expand_expr(), expand_insn(), expand_normal(), EXPAND_WRITE, gcc_assert, gen_reg_rtx(), gimple_call_arg(), gimple_call_lhs(), NULL_RTX, expand_operand::target, and targetm.

◆ expand_GOMP_SIMT_EXIT()

static void expand_GOMP_SIMT_EXIT ( internal_fn ,
gcall * stmt )
static 
Deallocate per-lane storage and leave non-uniform execution region.

References create_input_operand(), expand_insn(), expand_normal(), gcc_assert, gcc_checking_assert, gimple_call_arg(), gimple_call_lhs(), and targetm.

◆ expand_GOMP_SIMT_LANE()

static void expand_GOMP_SIMT_LANE ( internal_fn ,
gcall * stmt )
static 
Lane index on SIMT targets: thread index in the warp on NVPTX.  On targets
without SIMT execution this should be expanded in omp_device_lower pass.

References emit_insn(), expand_expr(), EXPAND_WRITE, gcc_assert, gimple_call_lhs(), NULL_RTX, expand_operand::target, and targetm.

◆ expand_GOMP_SIMT_LAST_LANE()

static void expand_GOMP_SIMT_LAST_LANE ( internal_fn ,
gcall * stmt )
static 
Lane index of the first SIMT lane that supplies a non-zero argument.
This is a SIMT counterpart to GOMP_SIMD_LAST_LANE, used to represent the
lane that executed the last iteration for handling OpenMP lastprivate.

References assign_call_lhs(), create_call_lhs_operand(), create_input_operand(), expand_expr(), expand_insn(), expand_normal(), EXPAND_WRITE, gcc_assert, gimple_call_arg(), gimple_call_lhs(), expand_operand::mode, NULL_RTX, expand_operand::target, targetm, TREE_TYPE, and TYPE_MODE.

◆ expand_GOMP_SIMT_ORDERED_PRED()

static void expand_GOMP_SIMT_ORDERED_PRED ( internal_fn ,
gcall * stmt )
static 
Non-transparent predicate used in SIMT lowering of OpenMP "ordered".

References assign_call_lhs(), create_call_lhs_operand(), create_input_operand(), expand_expr(), expand_insn(), expand_normal(), EXPAND_WRITE, gcc_assert, gimple_call_arg(), gimple_call_lhs(), expand_operand::mode, NULL_RTX, expand_operand::target, targetm, TREE_TYPE, and TYPE_MODE.

◆ expand_GOMP_SIMT_VF()

static void expand_GOMP_SIMT_VF ( internal_fn ,
gcall *  )
static 
This should get expanded in omp_device_lower pass.

References gcc_unreachable.

◆ expand_GOMP_SIMT_VOTE_ANY()

static void expand_GOMP_SIMT_VOTE_ANY ( internal_fn ,
gcall * stmt )
static 
"Or" boolean reduction across SIMT lanes: return non-zero in all lanes if
any lane supplies a non-zero argument.

References assign_call_lhs(), create_call_lhs_operand(), create_input_operand(), expand_expr(), expand_insn(), expand_normal(), EXPAND_WRITE, gcc_assert, gimple_call_arg(), gimple_call_lhs(), expand_operand::mode, NULL_RTX, expand_operand::target, targetm, TREE_TYPE, and TYPE_MODE.

◆ expand_GOMP_SIMT_XCHG_BFLY()

static void expand_GOMP_SIMT_XCHG_BFLY ( internal_fn ,
gcall * stmt )
static 
Exchange between SIMT lanes with a "butterfly" pattern: source lane index
is destination lane index XOR given offset.

References assign_call_lhs(), create_call_lhs_operand(), create_input_operand(), expand_expr(), expand_insn(), expand_normal(), EXPAND_WRITE, gcc_assert, gimple_call_arg(), gimple_call_lhs(), expand_operand::mode, NULL_RTX, expand_operand::target, targetm, TREE_TYPE, and TYPE_MODE.

◆ expand_GOMP_SIMT_XCHG_IDX()

static void expand_GOMP_SIMT_XCHG_IDX ( internal_fn ,
gcall * stmt )
static 
Exchange between SIMT lanes according to given source lane index.

References assign_call_lhs(), create_call_lhs_operand(), create_input_operand(), expand_expr(), expand_insn(), expand_normal(), EXPAND_WRITE, gcc_assert, gimple_call_arg(), gimple_call_lhs(), expand_operand::mode, NULL_RTX, expand_operand::target, targetm, TREE_TYPE, and TYPE_MODE.

◆ expand_GOMP_TARGET_REV()

static void expand_GOMP_TARGET_REV ( internal_fn ,
gcall *  )
static 
This should get expanded in omp_device_lower pass.

References gcc_unreachable.

◆ expand_GOMP_USE_SIMT()

static void expand_GOMP_USE_SIMT ( internal_fn ,
gcall *  )
static 
This should get expanded in omp_device_lower pass.

References gcc_unreachable.

◆ expand_HWASAN_ALLOCA_UNPOISON()

static void expand_HWASAN_ALLOCA_UNPOISON ( internal_fn ,
gcall * gc )
static 
For hwasan stack tagging:
Clear tags on the dynamically allocated space.
For use after an object dynamically allocated on the stack goes out of
scope.

References emit_library_call_value(), expand_expr(), EXPAND_NORMAL, expand_simple_binop(), gcc_assert, gimple_call_arg(), HWASAN_STACK_BACKGROUND, init_one_libfunc(), LCT_NORMAL, NULL_RTX, OPTAB_WIDEN, ptr_mode, stack_pointer_rtx, and virtual_stack_dynamic_rtx.

◆ expand_HWASAN_CHECK()

static void expand_HWASAN_CHECK ( internal_fn ,
gcall *  )
static 
This should get expanded in the sanopt pass.

References gcc_unreachable.

◆ expand_HWASAN_CHOOSE_TAG()

static void expand_HWASAN_CHOOSE_TAG ( internal_fn ,
gcall * gc )
static 
For hwasan stack tagging:
Return a tag to be used for a dynamic allocation.

References emit_move_insn(), expand_expr(), EXPAND_NORMAL, expand_simple_binop(), gcc_assert, gen_int_mode(), GET_MODE, gimple_call_lhs(), hwasan_current_frame_tag(), hwasan_frame_base(), hwasan_increment_frame_tag(), hwasan_truncate_to_tag_size(), expand_operand::mode, NULL_RTX, OPTAB_WIDEN, expand_operand::target, and targetm.

◆ expand_HWASAN_MARK()

static void expand_HWASAN_MARK ( internal_fn ,
gcall * gc )
static 
For hwasan stack tagging:
Tag a region of space in the shadow stack according to the base pointer of
an object on the stack.  N.b. the length provided in the internal call is
required to be aligned to HWASAN_TAG_GRANULE_SIZE.

References emit_library_call(), expand_normal(), gcc_assert, gcc_checking_assert, gimple_call_arg(), HWASAN_STACK_BACKGROUND, init_one_libfunc(), LCT_NORMAL, NULL_RTX, ptr_mode, targetm, TREE_CODE, and tree_to_shwi().

◆ expand_HWASAN_SET_TAG()

static void expand_HWASAN_SET_TAG ( internal_fn ,
gcall * gc )
static 
For hwasan stack tagging:
Store a tag into a pointer.

References emit_move_insn(), expand_expr(), EXPAND_NORMAL, expand_normal(), gcc_assert, gimple_call_arg(), gimple_call_lhs(), NULL_RTX, ptr_mode, expand_operand::target, and targetm.

◆ expand_internal_call() [1/2]

void expand_internal_call ( gcall * stmt) 
Expand STMT, which is a call to internal function FN.

References expand_internal_call(), and gimple_call_internal_fn().

◆ expand_internal_call() [2/2]

void expand_internal_call ( internal_fn fn,
gcall * stmt ) 
Expand STMT as though it were a call to internal function FN.

References internal_fn_expanders.

Referenced by expand_call_stmt(), and expand_internal_call().

◆ expand_LAUNDER()

static void expand_LAUNDER ( internal_fn ,
gcall * call )
static 
Expand LAUNDER to assignment, lhs = arg0.

References expand_assignment(), gimple_call_arg(), and gimple_call_lhs().

◆ expand_load_lanes_optab_fn()

static void expand_load_lanes_optab_fn ( internal_fn ,
gcall * stmt,
convert_optab optab )
static 
Expand LOAD_LANES call STMT using optab OPTAB.

References assign_call_lhs(), create_call_lhs_operand(), create_fixed_operand(), expand_expr(), expand_insn(), expand_normal(), EXPAND_WRITE, gcc_assert, get_multi_vector_move(), gimple_call_arg(), gimple_call_lhs(), MEM_P, NULL_RTX, PUT_MODE(), expand_operand::target, TREE_TYPE, type(), and TYPE_MODE.

◆ expand_LOOP_DIST_ALIAS()

static void expand_LOOP_DIST_ALIAS ( internal_fn ,
gcall *  )
static 
This should get folded in tree-vectorizer.cc.

References gcc_unreachable.

◆ expand_LOOP_VECTORIZED()

static void expand_LOOP_VECTORIZED ( internal_fn ,
gcall *  )
static 
This should get folded in tree-vectorizer.cc.

References gcc_unreachable.

◆ expand_MASK_CALL()

void expand_MASK_CALL ( internal_fn ,
gcall *  )

References gcc_unreachable.

◆ expand_MUL_OVERFLOW()

static void expand_MUL_OVERFLOW ( internal_fn ,
gcall * stmt )
static 
Expand MUL_OVERFLOW STMT.

References expand_arith_overflow().

◆ expand_mul_overflow()

static void expand_mul_overflow ( location_t loc,
tree lhs,
tree arg0,
tree arg1,
bool unsr_p,
bool uns0_p,
bool uns1_p,
bool is_ubsan,
tree * datap )
static 
Add mul overflow checking to the statement STMT.

References add_reg_br_prob_note(), any_condjump_p(), build_nonstandard_integer_type(), can_mult_highpart_p(), can_widen_mult_without_libcall(), cfun, separate_ops::code, const0_rtx, const1_rtx, constm1_rtx, convert_modes(), create_fixed_operand(), create_input_operand(), create_output_operand(), delete_insns_since(), do_compare_rtx_and_jump(), do_pending_stack_adjust(), emit_jump(), emit_label(), emit_move_insn(), error_mark_node, profile_probability::even(), expand_arith_overflow_result_store(), expand_arith_set_overflow(), expand_binop(), expand_expr(), expand_expr_real_2(), EXPAND_NORMAL, expand_normal(), expand_shift(), expand_simple_binop(), expand_ubsan_result_store(), expand_unop(), EXPAND_WRITE, find_reg_note(), force_reg(), gcc_assert, gcc_unreachable, gen_label_rtx(), gen_reg_rtx(), get_last_insn(), get_min_precision(), GET_MODE_2XWIDER_MODE(), GET_MODE_PRECISION(), get_range_pos_neg(), gimple_assign_rhs_code(), immed_wide_int_const(), int_mode_for_size(), integer_pow2p(), is_gimple_assign(), JUMP_P, last, separate_ops::location, make_tree(), maybe_expand_insn(), wi::min_value(), expand_operand::mode, NULL, NULL_RTX, NULL_TREE, separate_ops::op0, separate_ops::op1, separate_ops::op2, optab_handler(), OPTAB_LIB_WIDEN, OPTAB_WIDEN, optimize_insn_for_speed_p(), pop_temp_slots(), PROFILE_ABSENT, profile_status_for_fn, push_temp_slots(), SCALAR_INT_TYPE_MODE, SIGNED, single_imm_use(), expand_operand::target, targetm, tree_log2(), TREE_TYPE, separate_ops::type, type(), TYPE_PRECISION, ubsan_build_overflow_builtin(), profile_probability::unlikely(), UNSIGNED, profile_probability::very_likely(), profile_probability::very_unlikely(), and write_complex_part().

Referenced by expand_arith_overflow(), expand_UBSAN_CHECK_MUL(), and expand_vector_ubsan_overflow().

◆ expand_MULBITINT()

void expand_MULBITINT ( internal_fn ,
gcall * stmt )

References emit_library_call_value_1(), expand_normal(), gimple_call_arg(), i, init_one_libfunc(), LCT_NORMAL, NULL_RTX, and ptr_mode.

◆ expand_neg_overflow()

static void expand_neg_overflow ( location_t loc,
tree lhs,
tree arg1,
bool is_ubsan,
tree * datap )
static 
Add negate overflow checking to the statement STMT.

References add_reg_br_prob_note(), any_condjump_p(), cfun, const0_rtx, create_fixed_operand(), create_input_operand(), create_output_operand(), delete_insns_since(), do_compare_rtx_and_jump(), do_pending_stack_adjust(), emit_jump(), emit_label(), expand_arith_overflow_result_store(), expand_arith_set_overflow(), expand_expr(), expand_normal(), expand_ubsan_result_store(), expand_unop(), EXPAND_WRITE, find_reg_note(), gen_label_rtx(), gen_reg_rtx(), get_last_insn(), JUMP_P, last, maybe_expand_insn(), expand_operand::mode, NULL, NULL_RTX, NULL_TREE, optab_handler(), pop_temp_slots(), PROFILE_ABSENT, profile_status_for_fn, push_temp_slots(), SCALAR_INT_TYPE_MODE, expand_operand::target, TREE_TYPE, TYPE_MIN_VALUE, ubsan_build_overflow_builtin(), profile_probability::very_likely(), profile_probability::very_unlikely(), and write_complex_part().

Referenced by expand_arith_overflow(), expand_UBSAN_CHECK_SUB(), and expand_vector_ubsan_overflow().

◆ expand_NOP()

static void expand_NOP ( internal_fn ,
gcall *  )
static 
Expand a NOP.

◆ expand_PARITY()

void expand_PARITY ( internal_fn fn,
gcall * stmt )

References expand_bitquery(), and expand_unary_optab_fn.

◆ expand_partial_load_optab_fn()

static void expand_partial_load_optab_fn ( internal_fn ifn,
gcall * stmt,
convert_optab optab )
static 
Expand MASK_LOAD{,_LANES}, MASK_LEN_LOAD or LEN_LOAD call STMT using optab
* OPTAB.

References add_mask_and_len_args(), assign_call_lhs(), clear_mem_offset(), convert_optab_handler(), create_call_lhs_operand(), create_fixed_operand(), direct_optab_handler(), expand_call_mem_ref(), expand_expr(), expand_insn(), EXPAND_WRITE, gcc_assert, get_multi_vector_move(), gimple_call_arg(), gimple_call_lhs(), i, internal_fn_mask_index(), MEM_P, NULL_RTX, NULL_TREE, set_mem_expr(), expand_operand::target, TREE_TYPE, type(), and TYPE_MODE.

◆ expand_partial_store_optab_fn()

static void expand_partial_store_optab_fn ( internal_fn ifn,
gcall * stmt,
convert_optab optab )
static 
Expand MASK_STORE{,_LANES}, MASK_LEN_STORE or LEN_STORE call STMT using optab
* OPTAB.

References add_mask_and_len_args(), clear_mem_offset(), convert_optab_handler(), create_fixed_operand(), create_input_operand(), direct_optab_handler(), expand_call_mem_ref(), expand_expr(), expand_insn(), expand_normal(), EXPAND_WRITE, gcc_assert, get_multi_vector_move(), gimple_call_arg(), i, internal_fn_mask_index(), internal_fn_stored_value_index(), MEM_P, NULL_RTX, NULL_TREE, set_mem_expr(), TREE_TYPE, type(), and TYPE_MODE.

◆ expand_PHI()

void expand_PHI ( internal_fn ,
gcall *  )

References gcc_unreachable.

◆ expand_POPCOUNT()

void expand_POPCOUNT ( internal_fn fn,
gcall * stmt )

References const0_rtx, const1_rtx, const2_rtx, constm1_rtx, convert_to_mode(), do_pending_stack_adjust(), dump_file, dump_flags, emit_insn(), emit_move_insn(), emit_store_flag(), end_sequence(), expand_bitquery(), expand_normal(), expand_simple_binop(), expand_unary_optab_fn, get_insns(), GET_MODE, gimple_call_arg(), gimple_call_lhs(), gimple_call_num_args(), integer_minus_onep(), integer_zerop(), expand_operand::mode, NULL_RTX, OPTAB_WIDEN, optimize_insn_for_speed_p(), seq_cost(), start_sequence(), TDF_DETAILS, TREE_TYPE, and TYPE_MODE.

◆ expand_RAWMEMCHR()

void expand_RAWMEMCHR ( internal_fn ,
gcall * stmt ) 
Expand IFN_RAWMEMCHR internal function.

References assign_call_lhs(), create_call_lhs_operand(), create_fixed_operand(), create_input_operand(), direct_optab_handler(), expand_expr(), expand_insn(), expand_normal(), EXPAND_WRITE, get_memory_rtx(), gimple_call_arg(), gimple_call_lhs(), expand_operand::mode, NULL, NULL_RTX, TREE_TYPE, and TYPE_MODE.

◆ expand_scatter_store_optab_fn()

static void expand_scatter_store_optab_fn ( internal_fn ,
gcall * stmt,
direct_optab optab )
static 
Expand {MASK_,}SCATTER_STORE{S,U} call CALL using optab OPTAB.

References add_mask_and_len_args(), convert_optab_handler(), create_address_operand(), create_input_operand(), create_integer_operand(), expand_insn(), expand_normal(), gimple_call_arg(), gimple_call_internal_fn(), i, internal_fn_stored_value_index(), offset, tree_to_shwi(), TREE_TYPE, TYPE_MODE, and TYPE_UNSIGNED.

◆ expand_SET_EDOM()

static void expand_SET_EDOM ( internal_fn ,
gcall *  )
static 
Set errno to EDOM.

References emit_move_insn(), gcc_unreachable, gen_int_mode(), gen_rtx_MEM(), GET_MODE, and word_mode.

◆ expand_SHUFFLEVECTOR()

void expand_SHUFFLEVECTOR ( internal_fn ,
gcall *  )

References gcc_unreachable.

◆ expand_SPACESHIP()

void expand_SPACESHIP ( internal_fn ,
gcall * stmt )

References assign_call_lhs(), create_call_lhs_operand(), create_input_operand(), do_pending_stack_adjust(), expand_expr(), expand_insn(), expand_normal(), EXPAND_WRITE, gimple_call_arg(), gimple_call_lhs(), NULL_RTX, separate_ops::op1, separate_ops::op2, optab_handler(), expand_operand::target, TREE_TYPE, and TYPE_MODE.

◆ expand_store_lanes_optab_fn()

static void expand_store_lanes_optab_fn ( internal_fn ,
gcall * stmt,
convert_optab optab )
static 
Expand STORE_LANES call STMT using optab OPTAB.

References create_fixed_operand(), create_input_operand(), expand_expr(), expand_insn(), expand_normal(), EXPAND_WRITE, gcc_assert, get_multi_vector_move(), gimple_call_arg(), gimple_call_lhs(), MEM_P, NULL_RTX, PUT_MODE(), expand_operand::target, TREE_TYPE, type(), and TYPE_MODE.

◆ expand_SUB_OVERFLOW()

static void expand_SUB_OVERFLOW ( internal_fn ,
gcall * stmt )
static 
Expand SUB_OVERFLOW STMT.

References expand_arith_overflow().

◆ expand_TSAN_FUNC_EXIT()

static void expand_TSAN_FUNC_EXIT ( internal_fn ,
gcall *  )
static 
This should get expanded in the tsan pass.

References gcc_unreachable.

◆ expand_UADDC()

static void expand_UADDC ( internal_fn ifn,
gcall * stmt )
static 
Expand UADDC STMT.

References create_input_operand(), create_output_operand(), expand_expr(), expand_insn(), expand_normal(), EXPAND_WRITE, gen_reg_rtx(), gimple_call_arg(), gimple_call_lhs(), expand_operand::mode, NULL_RTX, separate_ops::op1, separate_ops::op2, optab_handler(), expand_operand::target, TREE_TYPE, TYPE_MODE, and write_complex_part().

Referenced by expand_USUBC().

◆ expand_UBSAN_BOUNDS()

static void expand_UBSAN_BOUNDS ( internal_fn ,
gcall *  )
static 
This should get expanded in the sanopt pass.

References gcc_unreachable.

◆ expand_UBSAN_CHECK_ADD()

static void expand_UBSAN_CHECK_ADD ( internal_fn ,
gcall * stmt )
static 
Expand UBSAN_CHECK_ADD call STMT.

References expand_addsub_overflow(), expand_vector_ubsan_overflow(), gimple_call_arg(), gimple_call_lhs(), gimple_location(), NULL, TREE_TYPE, and VECTOR_TYPE_P.

◆ expand_UBSAN_CHECK_MUL()

static void expand_UBSAN_CHECK_MUL ( internal_fn ,
gcall * stmt )
static 
Expand UBSAN_CHECK_MUL call STMT.

References expand_mul_overflow(), expand_vector_ubsan_overflow(), gimple_call_arg(), gimple_call_lhs(), gimple_location(), NULL, TREE_TYPE, and VECTOR_TYPE_P.

◆ expand_UBSAN_CHECK_SUB()

static void expand_UBSAN_CHECK_SUB ( internal_fn ,
gcall * stmt )
static 
Expand UBSAN_CHECK_SUB call STMT.

References expand_addsub_overflow(), expand_neg_overflow(), expand_vector_ubsan_overflow(), gimple_call_arg(), gimple_call_lhs(), gimple_location(), integer_zerop(), NULL, TREE_TYPE, and VECTOR_TYPE_P.

◆ expand_UBSAN_NULL()

static void expand_UBSAN_NULL ( internal_fn ,
gcall *  )
static 
This should get expanded in the sanopt pass.

References gcc_unreachable.

◆ expand_UBSAN_OBJECT_SIZE()

static void expand_UBSAN_OBJECT_SIZE ( internal_fn ,
gcall *  )
static 
This should get expanded in the sanopt pass.

References gcc_unreachable.

◆ expand_UBSAN_PTR()

static void expand_UBSAN_PTR ( internal_fn ,
gcall *  )
static 
This should get expanded in the sanopt pass.

References gcc_unreachable.

◆ expand_ubsan_result_store()

static void expand_ubsan_result_store ( tree lhs,
rtx target,
scalar_int_mode mode,
rtx res,
rtx_code_label * do_error )
static 
Helper for expand_*_overflow.  Store RES into TARGET.

References convert_move(), do_compare_rtx_and_jump(), emit_move_insn(), expand_shift(), expand_simple_binop(), gen_reg_rtx(), GET_CODE, GET_MODE_PRECISION(), immed_wide_int_const(), expand_operand::mode, NULL, NULL_RTX, OPTAB_LIB_WIDEN, wi::shifted_mask(), SUBREG_PROMOTED_SIGN, SUBREG_PROMOTED_VAR_P, SUBREG_REG, expand_operand::target, TREE_CODE, TREE_TYPE, TYPE_PRECISION, TYPE_UNSIGNED, and profile_probability::very_unlikely().

Referenced by expand_addsub_overflow(), expand_mul_overflow(), and expand_neg_overflow().

◆ expand_UBSAN_VPTR()

static void expand_UBSAN_VPTR ( internal_fn ,
gcall *  )
static 
This should get expanded in the sanopt pass.

References gcc_unreachable.

◆ expand_UNIQUE()

static void expand_UNIQUE ( internal_fn ,
gcall * stmt )
static 
Expand the IFN_UNIQUE function according to its first argument.

References const0_rtx, emit_insn(), expand_expr(), expand_normal(), EXPAND_WRITE, gcc_unreachable, gimple_call_arg(), gimple_call_lhs(), NULL_RTX, expand_operand::target, targetm, and TREE_INT_CST_LOW.

◆ expand_USUBC()

static void expand_USUBC ( internal_fn ifn,
gcall * stmt )
static 
Expand USUBC STMT.

References expand_UADDC().

◆ expand_VA_ARG()

static void expand_VA_ARG ( internal_fn ,
gcall *  )
static 
IFN_VA_ARG is supposed to be expanded at pass_stdarg.  So this dummy function
should never be called.

References gcc_unreachable.

◆ expand_vec_cond_mask_optab_fn()

static void expand_vec_cond_mask_optab_fn ( internal_fn ,
gcall * stmt,
convert_optab optab )
static 
Expand VCOND_MASK optab internal function.
The expansion of STMT happens based on OPTAB table associated.

References assign_call_lhs(), convert_optab_handler(), create_call_lhs_operand(), create_input_operand(), expand_expr(), expand_insn(), expand_normal(), EXPAND_WRITE, gcc_assert, gimple_call_arg(), gimple_call_lhs(), expand_operand::mode, NULL_RTX, expand_operand::target, TREE_TYPE, and TYPE_MODE.

◆ expand_vec_cond_optab_fn()

static void expand_vec_cond_optab_fn ( internal_fn ,
gcall * stmt,
convert_optab optab )
static 
Expand VCOND, VCONDU and VCONDEQ optab internal functions.
The expansion of STMT happens based on OPTAB table associated.

References assign_call_lhs(), convert_optab_handler(), create_call_lhs_operand(), create_fixed_operand(), create_input_operand(), expand_expr(), expand_insn(), expand_normal(), EXPAND_WRITE, gimple_call_arg(), gimple_call_lhs(), int_cst_value(), expand_operand::mode, NULL_RTX, operand_equal_p(), expand_operand::target, TREE_TYPE, TYPE_MODE, TYPE_UNSIGNED, vector_compare_rtx(), and XEXP.

◆ expand_VEC_CONVERT()

static void expand_VEC_CONVERT ( internal_fn ,
gcall *  )
static 
IFN_VEC_CONVERT is supposed to be expanded at pass_lower_vector.  So this
dummy function should never be called.

References gcc_unreachable.

◆ expand_vec_set_optab_fn()

static void expand_vec_set_optab_fn ( internal_fn ,
gcall * stmt,
convert_optab optab )
static 
Expand VEC_SET internal functions.

References create_convert_operand_from(), create_fixed_operand(), create_input_operand(), emit_move_insn(), expand_expr(), expand_normal(), EXPAND_WRITE, gcc_unreachable, gen_reg_rtx(), GET_MODE_INNER, gimple_call_arg(), gimple_call_lhs(), maybe_expand_insn(), NULL_RTX, optab_handler(), expand_operand::target, TREE_TYPE, TYPE_MODE, and expand_operand::value.

◆ expand_vector_ubsan_overflow()

static void expand_vector_ubsan_overflow ( location_t loc,
enum tree_code code,
tree lhs,
tree arg0,
tree arg1 )
static 
Expand UBSAN_CHECK_* internal function if it has vector operands.

References assign_temp(), bitsize_int, build4_loc(), build_array_type_nelts(), build_int_cst(), separate_ops::code, const0_rtx, do_compare_rtx_and_jump(), do_pending_stack_adjust(), emit_label(), emit_move_insn(), expand_addsub_overflow(), expand_expr(), expand_expr_real_2(), expand_mul_overflow(), expand_neg_overflow(), EXPAND_NORMAL, expand_normal(), EXPAND_WRITE, fold_build1_loc(), fold_build3_loc(), gcc_unreachable, gen_int_mode(), gen_label_rtx(), gen_reg_rtx(), GET_MODE, i, integer_zerop(), poly_int< N, C >::is_constant(), separate_ops::location, make_tree(), MEM_P, NULL, NULL_RTX, NULL_TREE, separate_ops::op0, separate_ops::op1, separate_ops::op2, optab_default, optab_for_tree_code(), optab_handler(), sizetype, TREE_CODE, tree_to_uhwi(), TREE_TYPE, separate_ops::type, TYPE_MODE, TYPE_SIZE, TYPE_VECTOR_SUBPARTS(), uniform_vector_p(), unknown_optab, VECTOR_MODE_P, and profile_probability::very_likely().

Referenced by expand_UBSAN_CHECK_ADD(), expand_UBSAN_CHECK_MUL(), and expand_UBSAN_CHECK_SUB().

◆ expand_while_optab_fn()

static void expand_while_optab_fn ( internal_fn ,
gcall * stmt,
convert_optab optab )
static 
Expand WHILE_ULT call STMT using optab OPTAB.

References assign_call_lhs(), convert_optab_handler(), create_call_lhs_operand(), create_input_operand(), create_integer_operand(), expand_expr(), expand_insn(), expand_normal(), EXPAND_WRITE, gimple_call_arg(), gimple_call_lhs(), i, NULL_RTX, TREE_TYPE, TYPE_MODE, TYPE_VECTOR_SUBPARTS(), and VECTOR_MODE_P.

◆ first_commutative_argument()

int first_commutative_argument ( internal_fn fn) 
If FN is commutative in two consecutive arguments, return the
index of the first, otherwise return -1.

References commutative_binary_fn_p(), and commutative_ternary_fn_p().

◆ get_conditional_internal_fn() [1/2]

internal_fn get_conditional_internal_fn ( internal_fn fn) 
Return a function that only performs internal function FN when a
certain condition is met and that uses a given fallback value otherwise.
In other words, the returned function FN' is such that:

  LHS = FN' (COND, A1, ... An, ELSE)

is equivalent to the C expression:

  LHS = COND ? FN (A1, ..., An) : ELSE;

operating elementwise if the operands are vectors.

Return IFN_LAST if no such function exists.

References CASE, and FOR_EACH_COND_FN_PAIR.

◆ get_conditional_internal_fn() [2/2]

internal_fn get_conditional_internal_fn ( tree_code code) 
Return a function that only performs CODE when a certain condition is met
and that uses a given fallback value otherwise.  For example, if CODE is
a binary operation associated with conditional function FN:

  LHS = FN (COND, A, B, ELSE)

is equivalent to the C expression:

  LHS = COND ? A CODE B : ELSE;

operating elementwise if the operands are vectors.

Return IFN_LAST if no such function exists.

References CASE, separate_ops::code, and FOR_EACH_CODE_MAPPING.

◆ get_conditional_len_internal_fn()

internal_fn get_conditional_len_internal_fn ( tree_code code) 
Like get_conditional_internal_fn, but return a function that
  additionally restricts the operation to the leading elements
  of a vector.  The number of elements to process is given by a length
  and bias pair, as for IFN_LOAD_LEN.  The values of the remaining
  elements are taken from the fallback ("else") argument.

  For example, if CODE is a binary operation associated with FN:

    LHS = FN (COND, A, B, ELSE, LEN, BIAS)

  is equivalent to the C code:

    for (int i = 0; i < NUNITS; i++)
     {
       if (i < LEN + BIAS && COND[i])
         LHS[i] = A[i] CODE B[i];
       else
         LHS[i] = ELSE[i];
     }

References CASE, separate_ops::code, and FOR_EACH_CODE_MAPPING.

Referenced by vectorizable_operation().

◆ get_len_internal_fn()

internal_fn get_len_internal_fn ( internal_fn fn) 
If there exists an internal function like IFN that operates on vectors,
but with additional length and bias parameters, return the internal_fn
for that function, otherwise return IFN_LAST.   
Internal functions.
   Copyright (C) 2011-2024 Free Software Foundation, Inc.

This file is part of GCC.

GCC is free software; you can redistribute it and/or modify it under
the terms of the GNU General Public License as published by the Free
Software Foundation; either version 3, or (at your option) any later
version.

GCC is distributed in the hope that it will be useful, but WITHOUT ANY
WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
for more details.

You should have received a copy of the GNU General Public License
along with GCC; see the file COPYING3.  If not see
<http://www.gnu.org/licenses/>.   
This file specifies a list of internal "functions".  These functions
differ from built-in functions in that they have no linkage and cannot
be called directly by the user.  They represent operations that are only
synthesised by GCC itself.

Internal functions are used instead of tree codes if the operation
and its operands are more naturally represented as a GIMPLE_CALL
than a GIMPLE_ASSIGN.

Each entry in this file has one of the forms:

  DEF_INTERNAL_FN (NAME, FLAGS, FNSPEC)
  DEF_INTERNAL_OPTAB_FN (NAME, FLAGS, OPTAB, TYPE)
  DEF_INTERNAL_SIGNED_OPTAB_FN (NAME, FLAGS, SELECTOR, SIGNED_OPTAB,
                           UNSIGNED_OPTAB, TYPE)
  DEF_INTERNAL_FLT_FN (NAME, FLAGS, OPTAB, TYPE)
  DEF_INTERNAL_FLT_FLOATN_FN (NAME, FLAGS, OPTAB, TYPE)
  DEF_INTERNAL_INT_FN (NAME, FLAGS, OPTAB, TYPE)
  DEF_INTERNAL_INT_EXT_FN (NAME, FLAGS, OPTAB, TYPE)
  DEF_INTERNAL_COND_FN (NAME, FLAGS, OPTAB, TYPE)
  DEF_INTERNAL_SIGNED_COND_FN (NAME, FLAGS, OPTAB, TYPE)
  DEF_INTERNAL_WIDENING_OPTAB_FN (NAME, FLAGS, SELECTOR, SOPTAB, UOPTAB,
                             TYPE)

where NAME is the name of the function, FLAGS is a set of
ECF_* flags and FNSPEC is a string describing functions fnspec.

DEF_INTERNAL_OPTAB_FN defines an internal function that maps to a
direct optab.  The function should only be called with a given
set of types if the associated optab is available for the modes
of those types.  OPTAB says what optab to use (without the trailing
"_optab") and TYPE categorizes the optab based on its inputs and
outputs.  The possible types of optab are:

- mask_load: currently just maskload
- load_lanes: currently just vec_load_lanes
- mask_load_lanes: currently just vec_mask_load_lanes
- mask_len_load_lanes: currently just vec_mask_len_load_lanes
- gather_load: used for {mask_,mask_len_,}gather_load
- len_load: currently just len_load
- mask_len_load: currently just mask_len_load

- mask_store: currently just maskstore
- store_lanes: currently just vec_store_lanes
- mask_store_lanes: currently just vec_mask_store_lanes
- mask_len_store_lanes: currently just vec_mask_len_store_lanes
- scatter_store: used for {mask_,mask_len_,}scatter_store
- len_store: currently just len_store
- mask_len_store: currently just mask_len_store

- unary: a normal unary optab, such as vec_reverse_<mode>
- binary: a normal binary optab, such as vec_interleave_lo_<mode>
- ternary: a normal ternary optab, such as fma<mode>4

- unary_convert: a single-input conversion optab, such as
  lround<srcmode><dstmode>2.

- cond_binary: a conditional binary optab, such as cond_add<mode>
- cond_unary: a conditional unary optab, such as cond_neg<mode>
- cond_ternary: a conditional ternary optab, such as cond_fma_rev<mode>

- fold_left: for scalar = FN (scalar, vector), keyed off the vector mode
- check_ptrs: used for check_{raw,war}_ptrs

- cond_len_unary: a conditional unary optab, such as cond_len_neg<mode>
- cond_len_binary: a conditional binary optab, such as cond_len_add<mode>
- cond_len_ternary: a conditional ternary optab, such as
cond_len_fma_rev<mode>

DEF_INTERNAL_SIGNED_OPTAB_FN defines an internal function that
maps to one of two optabs, depending on the signedness of an input.
SIGNED_OPTAB and UNSIGNED_OPTAB are the optabs for signed and
unsigned inputs respectively, both without the trailing "_optab".
SELECTOR says which type in the tree_pair determines the signedness.

DEF_INTERNAL_FLT_FN is like DEF_INTERNAL_OPTAB_FN, but in addition,
the function implements the computational part of a built-in math
function BUILT_IN_<NAME>{F,,L}.  Unlike some built-in functions,
these internal functions never set errno.

DEF_INTERNAL_INT_FN is like DEF_INTERNAL_OPTAB_FN, but in addition
says that the function extends the C-level BUILT_IN_<NAME>{,L,LL,IMAX}
group of functions to any integral mode (including vector modes).

DEF_INTERNAL_INT_EXT_FN is like DEF_INTERNAL_INT_FN, except that it
has expand_##NAME defined in internal-fn.cc to override the
DEF_INTERNAL_INT_FN expansion behavior.

DEF_INTERNAL_WIDENING_OPTAB_FN is a wrapper that defines five internal
functions with DEF_INTERNAL_SIGNED_OPTAB_FN:
- one that describes a widening operation with the same number of elements
in the output and input vectors,
- two that describe a pair of high-low widening operations where the output
vectors each have half the number of elements of the input vectors,
corresponding to the result of the widening operation on the top half and
bottom half, these have the suffixes _HI and _LO,
- and two that describe a pair of even-odd widening operations where the
output vectors each have half the number of elements of the input vectors,
corresponding to the result of the widening operation on the even and odd
elements, these have the suffixes _EVEN and _ODD.
These five internal functions will require two optabs each, a SIGNED_OPTAB
and an UNSIGNED_OTPAB.

DEF_INTERNAL_COND_FN is a wrapper that defines 2 internal functions with
DEF_INTERNAL_OPTAB_FN:
- One is COND_* operations that are predicated by mask only. Such operations
  make sense for both vectors and scalars.
- The other is COND_LEN_* operations that are predicated by mask and len
  both. Such operations only make sense for vectors.

DEF_INTERNAL_SIGNED_COND_FN is like DEF_INTERNAL_COND_FN but defines intenal
functions with DEF_INTERNAL_SIGNED_OPTAB_FN.

Each entry must have a corresponding expander of the form:

  void expand_NAME (gimple_call stmt)

where STMT is the statement that performs the call.  These are generated
automatically for optab functions and call out to a function or macro
called expand_<TYPE>_optab_fn.   
Extract the last active element from a vector.   
Same, but return the first argument if no elements are active.   
Unary math functions.   
Floating-point to integer conversions.

??? Here we preserve the I/L/LL prefix convention from the
corresponding built-in functions, rather than make the internal
functions polymorphic in both the argument and the return types.
Perhaps an alternative would be to pass a zero of the required
return type as a second parameter.   
FP rounding.   
Binary math functions.   
FP scales.   
Ternary math functions.   
Unary integer ops.   
An unduplicable, uncombinable function.  Generally used to preserve
a CFG property in the face of jump threading, tail merging or
other such optimizations.  The first argument distinguishes
between uses.  See internal-fn.h for usage.   
A function to represent an artifical initialization to an uninitialized
automatic variable.   
A function to associate the access size and access mode information
with the corresponding reference to an object.  It only reads from the
2nd argument.   
DIM_SIZE and DIM_POS return the size of a particular compute
dimension and the executing thread's position within that
dimension.  DIM_POS is pure (and not const) so that it isn't
thought to clobber memory and can be gcse'd within a single
parallel region, but not across FORK/JOIN boundaries.  They take a
single INTEGER_CST argument.  This might be overly conservative.   
OpenACC looping abstraction.  See internal-fn.h for usage.   
OpenACC reduction abstraction.  See internal-fn.h  for usage.   
Openacc tile abstraction. Describes the spans of the element loop.
GOACC_TILE (num-loops, loop-no, tile-arg, tile-mask, element-mask).   
Set errno to EDOM, if GCC knows how to do that directly for the
current target.   
Atomic functions.  These don't have ECF_NOTHROW because for
-fnon-call-exceptions they can throw, otherwise we set
gimple_call_nothrow_p on it.   
To implement [[fallthrough]].  If the TREE_NOTHROW or GF_CALL_NOTHROW flag
is set on the call (normally redundant with ECF_NOTHROW), it marks
[[fallthrough]] at the end of C++ loop body.   
To implement __builtin_launder.   
Divmod function.   
For coroutines.   
A NOP function with arbitrary arguments and return value.   
Temporary vehicle for __builtin_shufflevector.   
<=> optimization.   
[[assume (cond)]].   
For if-conversion of inbranch SIMD clones.   
_BitInt support.   
Bitwise functions.

Referenced by convert_conditional_op(), and vectorizable_call().

◆ get_min_precision()

static int get_min_precision ( tree arg,
signop sign )
static 
Return minimum precision needed to represent all values
of ARG in SIGNed integral type.

References CONVERT_EXPR_CODE_P, CONVERT_EXPR_P, wi::ext(), g, get_global_range_query(), get_min_precision(), get_range_pos_neg(), gimple_assign_rhs1(), gimple_assign_rhs_code(), INTEGRAL_TYPE_P, is_gimple_assign(), MAX, MIN, wi::min_precision(), wi::neg_p(), r, SIGNED, SSA_NAME_DEF_STMT, wi::to_wide(), wi::to_widest(), TREE_CODE, TREE_OPERAND, TREE_TYPE, TYPE_PRECISION, TYPE_SIGN, TYPE_UNSIGNED, and UNSIGNED.

Referenced by expand_arith_overflow(), expand_mul_overflow(), and get_min_precision().

◆ get_multi_vector_move()

static enum insn_code get_multi_vector_move ( tree array_type,
convert_optab optab )
static 
ARRAY_TYPE is an array of vector modes.  Return the associated insn
for load-lanes-style optab OPTAB, or CODE_FOR_nothing if none.

References convert_optab_handler(), gcc_assert, TREE_CODE, TREE_TYPE, and TYPE_MODE.

Referenced by expand_load_lanes_optab_fn(), expand_partial_load_optab_fn(), expand_partial_store_optab_fn(), and expand_store_lanes_optab_fn().

◆ get_unconditional_internal_fn()

internal_fn get_unconditional_internal_fn ( internal_fn ifn) 
If IFN implements the conditional form of an unconditional internal
function, return that unconditional function, otherwise return IFN_LAST.

References CASE, and FOR_EACH_COND_FN_PAIR.

Referenced by internal_fn_mask_index(), and try_conditional_simplification().

◆ init_internal_fns()

void init_internal_fns ( ) 
Initialize internal function tables.   
Internal functions.
   Copyright (C) 2011-2024 Free Software Foundation, Inc.

This file is part of GCC.

GCC is free software; you can redistribute it and/or modify it under
the terms of the GNU General Public License as published by the Free
Software Foundation; either version 3, or (at your option) any later
version.

GCC is distributed in the hope that it will be useful, but WITHOUT ANY
WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
for more details.

You should have received a copy of the GNU General Public License
along with GCC; see the file COPYING3.  If not see
<http://www.gnu.org/licenses/>.   
This file specifies a list of internal "functions".  These functions
differ from built-in functions in that they have no linkage and cannot
be called directly by the user.  They represent operations that are only
synthesised by GCC itself.

Internal functions are used instead of tree codes if the operation
and its operands are more naturally represented as a GIMPLE_CALL
than a GIMPLE_ASSIGN.

Each entry in this file has one of the forms:

  DEF_INTERNAL_FN (NAME, FLAGS, FNSPEC)
  DEF_INTERNAL_OPTAB_FN (NAME, FLAGS, OPTAB, TYPE)
  DEF_INTERNAL_SIGNED_OPTAB_FN (NAME, FLAGS, SELECTOR, SIGNED_OPTAB,
                           UNSIGNED_OPTAB, TYPE)
  DEF_INTERNAL_FLT_FN (NAME, FLAGS, OPTAB, TYPE)
  DEF_INTERNAL_FLT_FLOATN_FN (NAME, FLAGS, OPTAB, TYPE)
  DEF_INTERNAL_INT_FN (NAME, FLAGS, OPTAB, TYPE)
  DEF_INTERNAL_INT_EXT_FN (NAME, FLAGS, OPTAB, TYPE)
  DEF_INTERNAL_COND_FN (NAME, FLAGS, OPTAB, TYPE)
  DEF_INTERNAL_SIGNED_COND_FN (NAME, FLAGS, OPTAB, TYPE)
  DEF_INTERNAL_WIDENING_OPTAB_FN (NAME, FLAGS, SELECTOR, SOPTAB, UOPTAB,
                             TYPE)

where NAME is the name of the function, FLAGS is a set of
ECF_* flags and FNSPEC is a string describing functions fnspec.

DEF_INTERNAL_OPTAB_FN defines an internal function that maps to a
direct optab.  The function should only be called with a given
set of types if the associated optab is available for the modes
of those types.  OPTAB says what optab to use (without the trailing
"_optab") and TYPE categorizes the optab based on its inputs and
outputs.  The possible types of optab are:

- mask_load: currently just maskload
- load_lanes: currently just vec_load_lanes
- mask_load_lanes: currently just vec_mask_load_lanes
- mask_len_load_lanes: currently just vec_mask_len_load_lanes
- gather_load: used for {mask_,mask_len_,}gather_load
- len_load: currently just len_load
- mask_len_load: currently just mask_len_load

- mask_store: currently just maskstore
- store_lanes: currently just vec_store_lanes
- mask_store_lanes: currently just vec_mask_store_lanes
- mask_len_store_lanes: currently just vec_mask_len_store_lanes
- scatter_store: used for {mask_,mask_len_,}scatter_store
- len_store: currently just len_store
- mask_len_store: currently just mask_len_store

- unary: a normal unary optab, such as vec_reverse_<mode>
- binary: a normal binary optab, such as vec_interleave_lo_<mode>
- ternary: a normal ternary optab, such as fma<mode>4

- unary_convert: a single-input conversion optab, such as
  lround<srcmode><dstmode>2.

- cond_binary: a conditional binary optab, such as cond_add<mode>
- cond_unary: a conditional unary optab, such as cond_neg<mode>
- cond_ternary: a conditional ternary optab, such as cond_fma_rev<mode>

- fold_left: for scalar = FN (scalar, vector), keyed off the vector mode
- check_ptrs: used for check_{raw,war}_ptrs

- cond_len_unary: a conditional unary optab, such as cond_len_neg<mode>
- cond_len_binary: a conditional binary optab, such as cond_len_add<mode>
- cond_len_ternary: a conditional ternary optab, such as
cond_len_fma_rev<mode>

DEF_INTERNAL_SIGNED_OPTAB_FN defines an internal function that
maps to one of two optabs, depending on the signedness of an input.
SIGNED_OPTAB and UNSIGNED_OPTAB are the optabs for signed and
unsigned inputs respectively, both without the trailing "_optab".
SELECTOR says which type in the tree_pair determines the signedness.

DEF_INTERNAL_FLT_FN is like DEF_INTERNAL_OPTAB_FN, but in addition,
the function implements the computational part of a built-in math
function BUILT_IN_<NAME>{F,,L}.  Unlike some built-in functions,
these internal functions never set errno.

DEF_INTERNAL_INT_FN is like DEF_INTERNAL_OPTAB_FN, but in addition
says that the function extends the C-level BUILT_IN_<NAME>{,L,LL,IMAX}
group of functions to any integral mode (including vector modes).

DEF_INTERNAL_INT_EXT_FN is like DEF_INTERNAL_INT_FN, except that it
has expand_##NAME defined in internal-fn.cc to override the
DEF_INTERNAL_INT_FN expansion behavior.

DEF_INTERNAL_WIDENING_OPTAB_FN is a wrapper that defines five internal
functions with DEF_INTERNAL_SIGNED_OPTAB_FN:
- one that describes a widening operation with the same number of elements
in the output and input vectors,
- two that describe a pair of high-low widening operations where the output
vectors each have half the number of elements of the input vectors,
corresponding to the result of the widening operation on the top half and
bottom half, these have the suffixes _HI and _LO,
- and two that describe a pair of even-odd widening operations where the
output vectors each have half the number of elements of the input vectors,
corresponding to the result of the widening operation on the even and odd
elements, these have the suffixes _EVEN and _ODD.
These five internal functions will require two optabs each, a SIGNED_OPTAB
and an UNSIGNED_OTPAB.

DEF_INTERNAL_COND_FN is a wrapper that defines 2 internal functions with
DEF_INTERNAL_OPTAB_FN:
- One is COND_* operations that are predicated by mask only. Such operations
  make sense for both vectors and scalars.
- The other is COND_LEN_* operations that are predicated by mask and len
  both. Such operations only make sense for vectors.

DEF_INTERNAL_SIGNED_COND_FN is like DEF_INTERNAL_COND_FN but defines intenal
functions with DEF_INTERNAL_SIGNED_OPTAB_FN.

Each entry must have a corresponding expander of the form:

  void expand_NAME (gimple_call stmt)

where STMT is the statement that performs the call.  These are generated
automatically for optab functions and call out to a function or macro
called expand_<TYPE>_optab_fn.   
Extract the last active element from a vector.   
Same, but return the first argument if no elements are active.   
Unary math functions.   
Floating-point to integer conversions.

??? Here we preserve the I/L/LL prefix convention from the
corresponding built-in functions, rather than make the internal
functions polymorphic in both the argument and the return types.
Perhaps an alternative would be to pass a zero of the required
return type as a second parameter.   
FP rounding.   
Binary math functions.   
FP scales.   
Ternary math functions.   
Unary integer ops.   
An unduplicable, uncombinable function.  Generally used to preserve
a CFG property in the face of jump threading, tail merging or
other such optimizations.  The first argument distinguishes
between uses.  See internal-fn.h for usage.   
A function to represent an artifical initialization to an uninitialized
automatic variable.   
A function to associate the access size and access mode information
with the corresponding reference to an object.  It only reads from the
2nd argument.   
DIM_SIZE and DIM_POS return the size of a particular compute
dimension and the executing thread's position within that
dimension.  DIM_POS is pure (and not const) so that it isn't
thought to clobber memory and can be gcse'd within a single
parallel region, but not across FORK/JOIN boundaries.  They take a
single INTEGER_CST argument.  This might be overly conservative.   
OpenACC looping abstraction.  See internal-fn.h for usage.   
OpenACC reduction abstraction.  See internal-fn.h  for usage.   
Openacc tile abstraction. Describes the spans of the element loop.
GOACC_TILE (num-loops, loop-no, tile-arg, tile-mask, element-mask).   
Set errno to EDOM, if GCC knows how to do that directly for the
current target.   
Atomic functions.  These don't have ECF_NOTHROW because for
-fnon-call-exceptions they can throw, otherwise we set
gimple_call_nothrow_p on it.   
To implement [[fallthrough]].  If the TREE_NOTHROW or GF_CALL_NOTHROW flag
is set on the call (normally redundant with ECF_NOTHROW), it marks
[[fallthrough]] at the end of C++ loop body.   
To implement __builtin_launder.   
Divmod function.   
For coroutines.   
A NOP function with arbitrary arguments and return value.   
Temporary vehicle for __builtin_shufflevector.   
<=> optimization.   
[[assume (cond)]].   
For if-conversion of inbranch SIMD clones.   
_BitInt support.   
Bitwise functions.

References internal_fn_fnspec_array.

Referenced by build_common_builtin_nodes().

◆ internal_check_ptrs_fn_supported_p()

bool internal_check_ptrs_fn_supported_p ( internal_fn ifn,
tree type,
poly_uint64 length,
unsigned int align ) 
Return true if the target supports IFN_CHECK_{RAW,WAR}_PTRS function IFN
for pointers of type TYPE when the accesses have LENGTH bytes and their
common byte alignment is ALIGN.

References direct_internal_fn_optab(), direct_optab_handler(), GEN_INT, immed_wide_int_const(), insn_operand_matches(), and TYPE_MODE.

Referenced by create_ifn_alias_checks().

◆ internal_fn_else_index()

int internal_fn_else_index ( internal_fn fn) 
If FN is an IFN_COND_* or IFN_COND_LEN_* function, return the index of the
argument that is used when the condition is false.  Return -1 otherwise.

Referenced by check_reduction_path(), and vect_transform_reduction().

◆ internal_fn_len_index()

int internal_fn_len_index ( internal_fn fn) 
If FN takes a vector len argument, return the index of that argument,
otherwise return -1.

Referenced by add_mask_and_len_args(), can_interpret_as_conditional_op_p(), gimple_fold_partial_load_store_mem_ref(), initialize_ao_ref_for_dse(), try_conditional_simplification(), vectorizable_call(), and vn_reference_lookup_3().

◆ internal_fn_mask_index()

int internal_fn_mask_index ( internal_fn fn) 
If FN takes a vector mask argument, return the index of that argument,
otherwise return -1.

References conditional_internal_fn_code(), and get_unconditional_internal_fn().

Referenced by add_mask_and_len_args(), exist_non_indexing_operands_for_use_p(), expand_partial_load_optab_fn(), expand_partial_store_optab_fn(), gimple_fold_partial_load_store_mem_ref(), ifcvt_can_hoist(), vect_analyze_slp(), vect_get_load_store_mask(), vect_get_smallest_scalar_type(), vect_recog_mask_conversion_pattern(), vect_reduction_update_partial_vector_usage(), vectorizable_call(), vectorizable_load(), vectorizable_store(), and vn_reference_lookup_3().

◆ internal_fn_stored_value_index()

int internal_fn_stored_value_index ( internal_fn fn) 
If FN takes a value that should be stored to memory, return the index
of that argument, otherwise return -1.

Referenced by call_may_clobber_ref_p_1(), exist_non_indexing_operands_for_use_p(), expand_partial_store_optab_fn(), expand_scatter_store_optab_fn(), get_mem_type_for_internal_fn(), gimple_fold_partial_store(), initialize_ao_ref_for_dse(), vect_check_store_rhs(), vect_get_smallest_scalar_type(), vect_get_store_rhs(), vect_recog_mask_conversion_pattern(), and vn_reference_lookup_3().

◆ internal_gather_scatter_fn_p()

bool internal_gather_scatter_fn_p ( internal_fn fn) 
Return true if IFN is some form of gather load or scatter store.

Referenced by exist_non_indexing_operands_for_use_p(), and vect_check_gather_scatter().

◆ internal_gather_scatter_fn_supported_p()

bool internal_gather_scatter_fn_supported_p ( internal_fn ifn,
tree vector_type,
tree memory_element_type,
tree offset_vector_type,
int scale ) 
Return true if the target supports gather load or scatter store function
IFN.  For loads, VECTOR_TYPE is the vector type of the load result,
while for stores it is the vector type of the stored data argument.
MEMORY_ELEMENT_TYPE is the type of the memory elements being loaded
or stored.  OFFSET_VECTOR_TYPE is the vector type that holds the
offset from the shared base address of each loaded or stored element.
SCALE is the amount by which these offsets should be multiplied
*after* they have been extended to address width.

References convert_optab_handler(), direct_internal_fn_optab(), GEN_INT, insn_operand_matches(), internal_load_fn_p(), tree_int_cst_equal(), TREE_TYPE, TYPE_MODE, TYPE_SIZE, TYPE_UNSIGNED, and TYPE_VECTOR_SUBPARTS().

Referenced by check_load_store_for_partial_vectors(), and vect_gather_scatter_fn_p().

◆ internal_len_load_store_bias()

signed char internal_len_load_store_bias ( internal_fn ifn,
machine_mode mode ) 
Return the supported bias for IFN which is either IFN_{LEN_,MASK_LEN_,}LOAD
or IFN_{LEN_,MASK_LEN_,}STORE.  For now we only support the biases of 0 and
-1 (in case 0 is not an allowable length for {len_,mask_len_}load or
{len_,mask_len_}store). If none of the biases match what the backend
provides, return VECT_PARTIAL_BIAS_UNSUPPORTED.

References convert_optab_handler(), direct_internal_fn_optab(), direct_optab_handler(), GEN_INT, insn_operand_matches(), targetm, and VECT_PARTIAL_BIAS_UNSUPPORTED.

Referenced by vect_verify_loop_lens().

◆ internal_load_fn_p()

bool internal_load_fn_p ( internal_fn fn) 
Return true if IFN is some form of load from memory.

Referenced by internal_gather_scatter_fn_supported_p(), vect_get_smallest_scalar_type(), vectorizable_call(), and vectorizable_load().

◆ internal_store_fn_p()

bool internal_store_fn_p ( internal_fn fn) 
Return true if IFN is some form of store to memory.

Referenced by vect_build_slp_tree_1(), vect_check_store_rhs(), vect_get_smallest_scalar_type(), vect_get_vector_types_for_stmt(), vect_recog_mask_conversion_pattern(), vectorizable_call(), vectorizable_store(), and vn_reference_lookup_3().

◆ lookup_evenodd_internal_fn()

void lookup_evenodd_internal_fn ( internal_fn ifn,
internal_fn * even,
internal_fn * odd )
extern 
Given an internal_fn IFN that is a widening function, return its
corresponding _EVEN and _ODD internal_fns in *EVEN and *ODD.   
Internal functions.
   Copyright (C) 2011-2024 Free Software Foundation, Inc.

This file is part of GCC.

GCC is free software; you can redistribute it and/or modify it under
the terms of the GNU General Public License as published by the Free
Software Foundation; either version 3, or (at your option) any later
version.

GCC is distributed in the hope that it will be useful, but WITHOUT ANY
WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
for more details.

You should have received a copy of the GNU General Public License
along with GCC; see the file COPYING3.  If not see
<http://www.gnu.org/licenses/>.   
This file specifies a list of internal "functions".  These functions
differ from built-in functions in that they have no linkage and cannot
be called directly by the user.  They represent operations that are only
synthesised by GCC itself.

Internal functions are used instead of tree codes if the operation
and its operands are more naturally represented as a GIMPLE_CALL
than a GIMPLE_ASSIGN.

Each entry in this file has one of the forms:

  DEF_INTERNAL_FN (NAME, FLAGS, FNSPEC)
  DEF_INTERNAL_OPTAB_FN (NAME, FLAGS, OPTAB, TYPE)
  DEF_INTERNAL_SIGNED_OPTAB_FN (NAME, FLAGS, SELECTOR, SIGNED_OPTAB,
                           UNSIGNED_OPTAB, TYPE)
  DEF_INTERNAL_FLT_FN (NAME, FLAGS, OPTAB, TYPE)
  DEF_INTERNAL_FLT_FLOATN_FN (NAME, FLAGS, OPTAB, TYPE)
  DEF_INTERNAL_INT_FN (NAME, FLAGS, OPTAB, TYPE)
  DEF_INTERNAL_INT_EXT_FN (NAME, FLAGS, OPTAB, TYPE)
  DEF_INTERNAL_COND_FN (NAME, FLAGS, OPTAB, TYPE)
  DEF_INTERNAL_SIGNED_COND_FN (NAME, FLAGS, OPTAB, TYPE)
  DEF_INTERNAL_WIDENING_OPTAB_FN (NAME, FLAGS, SELECTOR, SOPTAB, UOPTAB,
                             TYPE)

where NAME is the name of the function, FLAGS is a set of
ECF_* flags and FNSPEC is a string describing functions fnspec.

DEF_INTERNAL_OPTAB_FN defines an internal function that maps to a
direct optab.  The function should only be called with a given
set of types if the associated optab is available for the modes
of those types.  OPTAB says what optab to use (without the trailing
"_optab") and TYPE categorizes the optab based on its inputs and
outputs.  The possible types of optab are:

- mask_load: currently just maskload
- load_lanes: currently just vec_load_lanes
- mask_load_lanes: currently just vec_mask_load_lanes
- mask_len_load_lanes: currently just vec_mask_len_load_lanes
- gather_load: used for {mask_,mask_len_,}gather_load
- len_load: currently just len_load
- mask_len_load: currently just mask_len_load

- mask_store: currently just maskstore
- store_lanes: currently just vec_store_lanes
- mask_store_lanes: currently just vec_mask_store_lanes
- mask_len_store_lanes: currently just vec_mask_len_store_lanes
- scatter_store: used for {mask_,mask_len_,}scatter_store
- len_store: currently just len_store
- mask_len_store: currently just mask_len_store

- unary: a normal unary optab, such as vec_reverse_<mode>
- binary: a normal binary optab, such as vec_interleave_lo_<mode>
- ternary: a normal ternary optab, such as fma<mode>4

- unary_convert: a single-input conversion optab, such as
  lround<srcmode><dstmode>2.

- cond_binary: a conditional binary optab, such as cond_add<mode>
- cond_unary: a conditional unary optab, such as cond_neg<mode>
- cond_ternary: a conditional ternary optab, such as cond_fma_rev<mode>

- fold_left: for scalar = FN (scalar, vector), keyed off the vector mode
- check_ptrs: used for check_{raw,war}_ptrs

- cond_len_unary: a conditional unary optab, such as cond_len_neg<mode>
- cond_len_binary: a conditional binary optab, such as cond_len_add<mode>
- cond_len_ternary: a conditional ternary optab, such as
cond_len_fma_rev<mode>

DEF_INTERNAL_SIGNED_OPTAB_FN defines an internal function that
maps to one of two optabs, depending on the signedness of an input.
SIGNED_OPTAB and UNSIGNED_OPTAB are the optabs for signed and
unsigned inputs respectively, both without the trailing "_optab".
SELECTOR says which type in the tree_pair determines the signedness.

DEF_INTERNAL_FLT_FN is like DEF_INTERNAL_OPTAB_FN, but in addition,
the function implements the computational part of a built-in math
function BUILT_IN_<NAME>{F,,L}.  Unlike some built-in functions,
these internal functions never set errno.

DEF_INTERNAL_INT_FN is like DEF_INTERNAL_OPTAB_FN, but in addition
says that the function extends the C-level BUILT_IN_<NAME>{,L,LL,IMAX}
group of functions to any integral mode (including vector modes).

DEF_INTERNAL_INT_EXT_FN is like DEF_INTERNAL_INT_FN, except that it
has expand_##NAME defined in internal-fn.cc to override the
DEF_INTERNAL_INT_FN expansion behavior.

DEF_INTERNAL_WIDENING_OPTAB_FN is a wrapper that defines five internal
functions with DEF_INTERNAL_SIGNED_OPTAB_FN:
- one that describes a widening operation with the same number of elements
in the output and input vectors,
- two that describe a pair of high-low widening operations where the output
vectors each have half the number of elements of the input vectors,
corresponding to the result of the widening operation on the top half and
bottom half, these have the suffixes _HI and _LO,
- and two that describe a pair of even-odd widening operations where the
output vectors each have half the number of elements of the input vectors,
corresponding to the result of the widening operation on the even and odd
elements, these have the suffixes _EVEN and _ODD.
These five internal functions will require two optabs each, a SIGNED_OPTAB
and an UNSIGNED_OTPAB.

DEF_INTERNAL_COND_FN is a wrapper that defines 2 internal functions with
DEF_INTERNAL_OPTAB_FN:
- One is COND_* operations that are predicated by mask only. Such operations
  make sense for both vectors and scalars.
- The other is COND_LEN_* operations that are predicated by mask and len
  both. Such operations only make sense for vectors.

DEF_INTERNAL_SIGNED_COND_FN is like DEF_INTERNAL_COND_FN but defines intenal
functions with DEF_INTERNAL_SIGNED_OPTAB_FN.

Each entry must have a corresponding expander of the form:

  void expand_NAME (gimple_call stmt)

where STMT is the statement that performs the call.  These are generated
automatically for optab functions and call out to a function or macro
called expand_<TYPE>_optab_fn.   
Extract the last active element from a vector.   
Same, but return the first argument if no elements are active.   
Unary math functions.   
Floating-point to integer conversions.

??? Here we preserve the I/L/LL prefix convention from the
corresponding built-in functions, rather than make the internal
functions polymorphic in both the argument and the return types.
Perhaps an alternative would be to pass a zero of the required
return type as a second parameter.   
FP rounding.   
Binary math functions.   
FP scales.   
Ternary math functions.   
Unary integer ops.   
An unduplicable, uncombinable function.  Generally used to preserve
a CFG property in the face of jump threading, tail merging or
other such optimizations.  The first argument distinguishes
between uses.  See internal-fn.h for usage.   
A function to represent an artifical initialization to an uninitialized
automatic variable.   
A function to associate the access size and access mode information
with the corresponding reference to an object.  It only reads from the
2nd argument.   
DIM_SIZE and DIM_POS return the size of a particular compute
dimension and the executing thread's position within that
dimension.  DIM_POS is pure (and not const) so that it isn't
thought to clobber memory and can be gcse'd within a single
parallel region, but not across FORK/JOIN boundaries.  They take a
single INTEGER_CST argument.  This might be overly conservative.   
OpenACC looping abstraction.  See internal-fn.h for usage.   
OpenACC reduction abstraction.  See internal-fn.h  for usage.   
Openacc tile abstraction. Describes the spans of the element loop.
GOACC_TILE (num-loops, loop-no, tile-arg, tile-mask, element-mask).   
Set errno to EDOM, if GCC knows how to do that directly for the
current target.   
Atomic functions.  These don't have ECF_NOTHROW because for
-fnon-call-exceptions they can throw, otherwise we set
gimple_call_nothrow_p on it.   
To implement [[fallthrough]].  If the TREE_NOTHROW or GF_CALL_NOTHROW flag
is set on the call (normally redundant with ECF_NOTHROW), it marks
[[fallthrough]] at the end of C++ loop body.   
To implement __builtin_launder.   
Divmod function.   
For coroutines.   
A NOP function with arbitrary arguments and return value.   
Temporary vehicle for __builtin_shufflevector.   
<=> optimization.   
[[assume (cond)]].   
For if-conversion of inbranch SIMD clones.   
_BitInt support.   
Bitwise functions.

References gcc_assert, gcc_unreachable, and widening_fn_p().

Referenced by supportable_widening_operation().

◆ lookup_hilo_internal_fn()

void lookup_hilo_internal_fn ( internal_fn ifn,
internal_fn * lo,
internal_fn * hi )
extern 
Geven an internal_fn IFN that is a widening function, return its
corresponding LO and HI internal_fns.   
Internal functions.
   Copyright (C) 2011-2024 Free Software Foundation, Inc.

This file is part of GCC.

GCC is free software; you can redistribute it and/or modify it under
the terms of the GNU General Public License as published by the Free
Software Foundation; either version 3, or (at your option) any later
version.

GCC is distributed in the hope that it will be useful, but WITHOUT ANY
WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
for more details.

You should have received a copy of the GNU General Public License
along with GCC; see the file COPYING3.  If not see
<http://www.gnu.org/licenses/>.   
This file specifies a list of internal "functions".  These functions
differ from built-in functions in that they have no linkage and cannot
be called directly by the user.  They represent operations that are only
synthesised by GCC itself.

Internal functions are used instead of tree codes if the operation
and its operands are more naturally represented as a GIMPLE_CALL
than a GIMPLE_ASSIGN.

Each entry in this file has one of the forms:

  DEF_INTERNAL_FN (NAME, FLAGS, FNSPEC)
  DEF_INTERNAL_OPTAB_FN (NAME, FLAGS, OPTAB, TYPE)
  DEF_INTERNAL_SIGNED_OPTAB_FN (NAME, FLAGS, SELECTOR, SIGNED_OPTAB,
                           UNSIGNED_OPTAB, TYPE)
  DEF_INTERNAL_FLT_FN (NAME, FLAGS, OPTAB, TYPE)
  DEF_INTERNAL_FLT_FLOATN_FN (NAME, FLAGS, OPTAB, TYPE)
  DEF_INTERNAL_INT_FN (NAME, FLAGS, OPTAB, TYPE)
  DEF_INTERNAL_INT_EXT_FN (NAME, FLAGS, OPTAB, TYPE)
  DEF_INTERNAL_COND_FN (NAME, FLAGS, OPTAB, TYPE)
  DEF_INTERNAL_SIGNED_COND_FN (NAME, FLAGS, OPTAB, TYPE)
  DEF_INTERNAL_WIDENING_OPTAB_FN (NAME, FLAGS, SELECTOR, SOPTAB, UOPTAB,
                             TYPE)

where NAME is the name of the function, FLAGS is a set of
ECF_* flags and FNSPEC is a string describing functions fnspec.

DEF_INTERNAL_OPTAB_FN defines an internal function that maps to a
direct optab.  The function should only be called with a given
set of types if the associated optab is available for the modes
of those types.  OPTAB says what optab to use (without the trailing
"_optab") and TYPE categorizes the optab based on its inputs and
outputs.  The possible types of optab are:

- mask_load: currently just maskload
- load_lanes: currently just vec_load_lanes
- mask_load_lanes: currently just vec_mask_load_lanes
- mask_len_load_lanes: currently just vec_mask_len_load_lanes
- gather_load: used for {mask_,mask_len_,}gather_load
- len_load: currently just len_load
- mask_len_load: currently just mask_len_load

- mask_store: currently just maskstore
- store_lanes: currently just vec_store_lanes
- mask_store_lanes: currently just vec_mask_store_lanes
- mask_len_store_lanes: currently just vec_mask_len_store_lanes
- scatter_store: used for {mask_,mask_len_,}scatter_store
- len_store: currently just len_store
- mask_len_store: currently just mask_len_store

- unary: a normal unary optab, such as vec_reverse_<mode>
- binary: a normal binary optab, such as vec_interleave_lo_<mode>
- ternary: a normal ternary optab, such as fma<mode>4

- unary_convert: a single-input conversion optab, such as
  lround<srcmode><dstmode>2.

- cond_binary: a conditional binary optab, such as cond_add<mode>
- cond_unary: a conditional unary optab, such as cond_neg<mode>
- cond_ternary: a conditional ternary optab, such as cond_fma_rev<mode>

- fold_left: for scalar = FN (scalar, vector), keyed off the vector mode
- check_ptrs: used for check_{raw,war}_ptrs

- cond_len_unary: a conditional unary optab, such as cond_len_neg<mode>
- cond_len_binary: a conditional binary optab, such as cond_len_add<mode>
- cond_len_ternary: a conditional ternary optab, such as
cond_len_fma_rev<mode>

DEF_INTERNAL_SIGNED_OPTAB_FN defines an internal function that
maps to one of two optabs, depending on the signedness of an input.
SIGNED_OPTAB and UNSIGNED_OPTAB are the optabs for signed and
unsigned inputs respectively, both without the trailing "_optab".
SELECTOR says which type in the tree_pair determines the signedness.

DEF_INTERNAL_FLT_FN is like DEF_INTERNAL_OPTAB_FN, but in addition,
the function implements the computational part of a built-in math
function BUILT_IN_<NAME>{F,,L}.  Unlike some built-in functions,
these internal functions never set errno.

DEF_INTERNAL_INT_FN is like DEF_INTERNAL_OPTAB_FN, but in addition
says that the function extends the C-level BUILT_IN_<NAME>{,L,LL,IMAX}
group of functions to any integral mode (including vector modes).

DEF_INTERNAL_INT_EXT_FN is like DEF_INTERNAL_INT_FN, except that it
has expand_##NAME defined in internal-fn.cc to override the
DEF_INTERNAL_INT_FN expansion behavior.

DEF_INTERNAL_WIDENING_OPTAB_FN is a wrapper that defines five internal
functions with DEF_INTERNAL_SIGNED_OPTAB_FN:
- one that describes a widening operation with the same number of elements
in the output and input vectors,
- two that describe a pair of high-low widening operations where the output
vectors each have half the number of elements of the input vectors,
corresponding to the result of the widening operation on the top half and
bottom half, these have the suffixes _HI and _LO,
- and two that describe a pair of even-odd widening operations where the
output vectors each have half the number of elements of the input vectors,
corresponding to the result of the widening operation on the even and odd
elements, these have the suffixes _EVEN and _ODD.
These five internal functions will require two optabs each, a SIGNED_OPTAB
and an UNSIGNED_OTPAB.

DEF_INTERNAL_COND_FN is a wrapper that defines 2 internal functions with
DEF_INTERNAL_OPTAB_FN:
- One is COND_* operations that are predicated by mask only. Such operations
  make sense for both vectors and scalars.
- The other is COND_LEN_* operations that are predicated by mask and len
  both. Such operations only make sense for vectors.

DEF_INTERNAL_SIGNED_COND_FN is like DEF_INTERNAL_COND_FN but defines intenal
functions with DEF_INTERNAL_SIGNED_OPTAB_FN.

Each entry must have a corresponding expander of the form:

  void expand_NAME (gimple_call stmt)

where STMT is the statement that performs the call.  These are generated
automatically for optab functions and call out to a function or macro
called expand_<TYPE>_optab_fn.   
Extract the last active element from a vector.   
Same, but return the first argument if no elements are active.   
Unary math functions.   
Floating-point to integer conversions.

??? Here we preserve the I/L/LL prefix convention from the
corresponding built-in functions, rather than make the internal
functions polymorphic in both the argument and the return types.
Perhaps an alternative would be to pass a zero of the required
return type as a second parameter.   
FP rounding.   
Binary math functions.   
FP scales.   
Ternary math functions.   
Unary integer ops.   
An unduplicable, uncombinable function.  Generally used to preserve
a CFG property in the face of jump threading, tail merging or
other such optimizations.  The first argument distinguishes
between uses.  See internal-fn.h for usage.   
A function to represent an artifical initialization to an uninitialized
automatic variable.   
A function to associate the access size and access mode information
with the corresponding reference to an object.  It only reads from the
2nd argument.   
DIM_SIZE and DIM_POS return the size of a particular compute
dimension and the executing thread's position within that
dimension.  DIM_POS is pure (and not const) so that it isn't
thought to clobber memory and can be gcse'd within a single
parallel region, but not across FORK/JOIN boundaries.  They take a
single INTEGER_CST argument.  This might be overly conservative.   
OpenACC looping abstraction.  See internal-fn.h for usage.   
OpenACC reduction abstraction.  See internal-fn.h  for usage.   
Openacc tile abstraction. Describes the spans of the element loop.
GOACC_TILE (num-loops, loop-no, tile-arg, tile-mask, element-mask).   
Set errno to EDOM, if GCC knows how to do that directly for the
current target.   
Atomic functions.  These don't have ECF_NOTHROW because for
-fnon-call-exceptions they can throw, otherwise we set
gimple_call_nothrow_p on it.   
To implement [[fallthrough]].  If the TREE_NOTHROW or GF_CALL_NOTHROW flag
is set on the call (normally redundant with ECF_NOTHROW), it marks
[[fallthrough]] at the end of C++ loop body.   
To implement __builtin_launder.   
Divmod function.   
For coroutines.   
A NOP function with arbitrary arguments and return value.   
Temporary vehicle for __builtin_shufflevector.   
<=> optimization.   
[[assume (cond)]].   
For if-conversion of inbranch SIMD clones.   
_BitInt support.   
Bitwise functions.

References gcc_assert, gcc_unreachable, and widening_fn_p().

Referenced by supportable_widening_operation().

◆ lookup_internal_fn()

internal_fn lookup_internal_fn ( const char * name) 
Return the internal function called NAME, or IFN_LAST if there's
no such function.

References hash_map< KeyId, Value, Traits >::get(), i, and internal_fn_name().

◆ multi_vector_optab_supported_p()

static bool multi_vector_optab_supported_p ( convert_optab optab,
tree_pair types,
optimization_type opt_type )
static 
Return true if load/store lanes optab OPTAB is supported for
array type TYPES.first when the optimization type is OPT_TYPE.

References convert_optab_handler(), gcc_assert, TREE_CODE, TREE_TYPE, and TYPE_MODE.

◆ set_edom_supported_p()

bool set_edom_supported_p ( void ) 
Return true if IFN_SET_EDOM is supported.

Referenced by use_internal_fn().

◆ type_pair_strictly_matches_mode_p()

static bool type_pair_strictly_matches_mode_p ( tree_pair type_pair)
static 
Returns true if both types of TYPE_PAIR strictly match their modes,
else returns false.

References type_pair::first, type_pair::second, and type_strictly_matches_mode_p().

Referenced by direct_internal_fn_supported_p().

◆ type_strictly_matches_mode_p()

static bool type_strictly_matches_mode_p ( const_tree type)
static 
Return true if TYPE's mode has the same format as TYPE, and if there is
a 1:1 correspondence between the values that the mode can store and the
values that the type can store.

References COMPLEX_FLOAT_TYPE_P, INTEGRAL_TYPE_P, SCALAR_FLOAT_TYPE_P, SCALAR_INT_MODE_P, TREE_TYPE, type_has_mode_precision_p(), TYPE_MODE, TYPE_PRECISION, VECTOR_BOOLEAN_TYPE_P, VECTOR_MODE_P, and VECTOR_TYPE_P.

Referenced by type_pair_strictly_matches_mode_p().

◆ vectorized_internal_fn_supported_p()

bool vectorized_internal_fn_supported_p ( internal_fn ifn,
tree type ) 
If TYPE is a vector type, return true if IFN is a direct internal
function that is supported for that type.  If TYPE is a scalar type,
return true if IFN is a direct internal function that is supported for
the target's preferred vector version of TYPE.

References build_vector_type_for_mode(), direct_internal_fn_supported_p(), is_a(), OPTIMIZE_FOR_SPEED, related_vector_mode(), targetm, TYPE_MODE, VECTOR_MODE_P, and VECTOR_TYPE_P.

Referenced by convert_scalar_cond_reduction(), and ifcvt_can_predicate().

◆ widening_fn_p()

bool widening_fn_p ( code_helper code) 
Return true if this CODE describes an internal_fn that returns a vector with
elements twice as wide as the element size of the input vectors.   
Internal functions.
   Copyright (C) 2011-2024 Free Software Foundation, Inc.

This file is part of GCC.

GCC is free software; you can redistribute it and/or modify it under
the terms of the GNU General Public License as published by the Free
Software Foundation; either version 3, or (at your option) any later
version.

GCC is distributed in the hope that it will be useful, but WITHOUT ANY
WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
for more details.

You should have received a copy of the GNU General Public License
along with GCC; see the file COPYING3.  If not see
<http://www.gnu.org/licenses/>.   
This file specifies a list of internal "functions".  These functions
differ from built-in functions in that they have no linkage and cannot
be called directly by the user.  They represent operations that are only
synthesised by GCC itself.

Internal functions are used instead of tree codes if the operation
and its operands are more naturally represented as a GIMPLE_CALL
than a GIMPLE_ASSIGN.

Each entry in this file has one of the forms:

  DEF_INTERNAL_FN (NAME, FLAGS, FNSPEC)
  DEF_INTERNAL_OPTAB_FN (NAME, FLAGS, OPTAB, TYPE)
  DEF_INTERNAL_SIGNED_OPTAB_FN (NAME, FLAGS, SELECTOR, SIGNED_OPTAB,
                           UNSIGNED_OPTAB, TYPE)
  DEF_INTERNAL_FLT_FN (NAME, FLAGS, OPTAB, TYPE)
  DEF_INTERNAL_FLT_FLOATN_FN (NAME, FLAGS, OPTAB, TYPE)
  DEF_INTERNAL_INT_FN (NAME, FLAGS, OPTAB, TYPE)
  DEF_INTERNAL_INT_EXT_FN (NAME, FLAGS, OPTAB, TYPE)
  DEF_INTERNAL_COND_FN (NAME, FLAGS, OPTAB, TYPE)
  DEF_INTERNAL_SIGNED_COND_FN (NAME, FLAGS, OPTAB, TYPE)
  DEF_INTERNAL_WIDENING_OPTAB_FN (NAME, FLAGS, SELECTOR, SOPTAB, UOPTAB,
                             TYPE)

where NAME is the name of the function, FLAGS is a set of
ECF_* flags and FNSPEC is a string describing functions fnspec.

DEF_INTERNAL_OPTAB_FN defines an internal function that maps to a
direct optab.  The function should only be called with a given
set of types if the associated optab is available for the modes
of those types.  OPTAB says what optab to use (without the trailing
"_optab") and TYPE categorizes the optab based on its inputs and
outputs.  The possible types of optab are:

- mask_load: currently just maskload
- load_lanes: currently just vec_load_lanes
- mask_load_lanes: currently just vec_mask_load_lanes
- mask_len_load_lanes: currently just vec_mask_len_load_lanes
- gather_load: used for {mask_,mask_len_,}gather_load
- len_load: currently just len_load
- mask_len_load: currently just mask_len_load

- mask_store: currently just maskstore
- store_lanes: currently just vec_store_lanes
- mask_store_lanes: currently just vec_mask_store_lanes
- mask_len_store_lanes: currently just vec_mask_len_store_lanes
- scatter_store: used for {mask_,mask_len_,}scatter_store
- len_store: currently just len_store
- mask_len_store: currently just mask_len_store

- unary: a normal unary optab, such as vec_reverse_<mode>
- binary: a normal binary optab, such as vec_interleave_lo_<mode>
- ternary: a normal ternary optab, such as fma<mode>4

- unary_convert: a single-input conversion optab, such as
  lround<srcmode><dstmode>2.

- cond_binary: a conditional binary optab, such as cond_add<mode>
- cond_unary: a conditional unary optab, such as cond_neg<mode>
- cond_ternary: a conditional ternary optab, such as cond_fma_rev<mode>

- fold_left: for scalar = FN (scalar, vector), keyed off the vector mode
- check_ptrs: used for check_{raw,war}_ptrs

- cond_len_unary: a conditional unary optab, such as cond_len_neg<mode>
- cond_len_binary: a conditional binary optab, such as cond_len_add<mode>
- cond_len_ternary: a conditional ternary optab, such as
cond_len_fma_rev<mode>

DEF_INTERNAL_SIGNED_OPTAB_FN defines an internal function that
maps to one of two optabs, depending on the signedness of an input.
SIGNED_OPTAB and UNSIGNED_OPTAB are the optabs for signed and
unsigned inputs respectively, both without the trailing "_optab".
SELECTOR says which type in the tree_pair determines the signedness.

DEF_INTERNAL_FLT_FN is like DEF_INTERNAL_OPTAB_FN, but in addition,
the function implements the computational part of a built-in math
function BUILT_IN_<NAME>{F,,L}.  Unlike some built-in functions,
these internal functions never set errno.

DEF_INTERNAL_INT_FN is like DEF_INTERNAL_OPTAB_FN, but in addition
says that the function extends the C-level BUILT_IN_<NAME>{,L,LL,IMAX}
group of functions to any integral mode (including vector modes).

DEF_INTERNAL_INT_EXT_FN is like DEF_INTERNAL_INT_FN, except that it
has expand_##NAME defined in internal-fn.cc to override the
DEF_INTERNAL_INT_FN expansion behavior.

DEF_INTERNAL_WIDENING_OPTAB_FN is a wrapper that defines five internal
functions with DEF_INTERNAL_SIGNED_OPTAB_FN:
- one that describes a widening operation with the same number of elements
in the output and input vectors,
- two that describe a pair of high-low widening operations where the output
vectors each have half the number of elements of the input vectors,
corresponding to the result of the widening operation on the top half and
bottom half, these have the suffixes _HI and _LO,
- and two that describe a pair of even-odd widening operations where the
output vectors each have half the number of elements of the input vectors,
corresponding to the result of the widening operation on the even and odd
elements, these have the suffixes _EVEN and _ODD.
These five internal functions will require two optabs each, a SIGNED_OPTAB
and an UNSIGNED_OTPAB.

DEF_INTERNAL_COND_FN is a wrapper that defines 2 internal functions with
DEF_INTERNAL_OPTAB_FN:
- One is COND_* operations that are predicated by mask only. Such operations
  make sense for both vectors and scalars.
- The other is COND_LEN_* operations that are predicated by mask and len
  both. Such operations only make sense for vectors.

DEF_INTERNAL_SIGNED_COND_FN is like DEF_INTERNAL_COND_FN but defines intenal
functions with DEF_INTERNAL_SIGNED_OPTAB_FN.

Each entry must have a corresponding expander of the form:

  void expand_NAME (gimple_call stmt)

where STMT is the statement that performs the call.  These are generated
automatically for optab functions and call out to a function or macro
called expand_<TYPE>_optab_fn.   
Extract the last active element from a vector.   
Same, but return the first argument if no elements are active.   
Unary math functions.   
Floating-point to integer conversions.

??? Here we preserve the I/L/LL prefix convention from the
corresponding built-in functions, rather than make the internal
functions polymorphic in both the argument and the return types.
Perhaps an alternative would be to pass a zero of the required
return type as a second parameter.   
FP rounding.   
Binary math functions.   
FP scales.   
Ternary math functions.   
Unary integer ops.   
An unduplicable, uncombinable function.  Generally used to preserve
a CFG property in the face of jump threading, tail merging or
other such optimizations.  The first argument distinguishes
between uses.  See internal-fn.h for usage.   
A function to represent an artifical initialization to an uninitialized
automatic variable.   
A function to associate the access size and access mode information
with the corresponding reference to an object.  It only reads from the
2nd argument.   
DIM_SIZE and DIM_POS return the size of a particular compute
dimension and the executing thread's position within that
dimension.  DIM_POS is pure (and not const) so that it isn't
thought to clobber memory and can be gcse'd within a single
parallel region, but not across FORK/JOIN boundaries.  They take a
single INTEGER_CST argument.  This might be overly conservative.   
OpenACC looping abstraction.  See internal-fn.h for usage.   
OpenACC reduction abstraction.  See internal-fn.h  for usage.   
Openacc tile abstraction. Describes the spans of the element loop.
GOACC_TILE (num-loops, loop-no, tile-arg, tile-mask, element-mask).   
Set errno to EDOM, if GCC knows how to do that directly for the
current target.   
Atomic functions.  These don't have ECF_NOTHROW because for
-fnon-call-exceptions they can throw, otherwise we set
gimple_call_nothrow_p on it.   
To implement [[fallthrough]].  If the TREE_NOTHROW or GF_CALL_NOTHROW flag
is set on the call (normally redundant with ECF_NOTHROW), it marks
[[fallthrough]] at the end of C++ loop body.   
To implement __builtin_launder.   
Divmod function.   
For coroutines.   
A NOP function with arbitrary arguments and return value.   
Temporary vehicle for __builtin_shufflevector.   
<=> optimization.   
[[assume (cond)]].   
For if-conversion of inbranch SIMD clones.   
_BitInt support.   
Bitwise functions.

References as_internal_fn(), separate_ops::code, and internal_fn_p().

Referenced by lookup_evenodd_internal_fn(), lookup_hilo_internal_fn(), supportable_widening_operation(), and vectorizable_conversion().

Variable Documentation

◆ direct_internal_fn_array

const direct_internal_fn_info direct_internal_fn_array[IFN_LAST+1]

Referenced by direct_internal_fn(), direct_internal_fn_p(), and vectorizable_internal_fn_p().

◆ internal_fn_expanders

void(*const internal_fn_expanders[])(internal_fn, gcall *) ( internal_fn ,
gcall *  )
static 
Routines to expand each internal function, indexed by function number.
Each routine has the prototype:

    expand_<NAME> (gcall *stmt)

where STMT is the statement that performs the call.

Referenced by expand_internal_call().

◆ internal_fn_flags_array

const int internal_fn_flags_array[] 
The ECF_* flags of each internal function, indexed by function number.

Referenced by internal_fn_flags().

◆ internal_fn_fnspec_array

const_tree internal_fn_fnspec_array[IFN_LAST+1] 
Fnspec of each internal function, indexed by function number.

Referenced by init_internal_fns(), and internal_fn_fnspec().

◆ internal_fn_name_array

const char* const internal_fn_name_array[] 
Internal functions.
   Copyright (C) 2011-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/>.   
For lang_hooks.types.type_for_mode.   
The names of each internal function, indexed by function number.

Referenced by internal_fn_name().